阿辉的博客

gitPage作为博客

2020-03-12T10:21:00+00:00

使用GitPage 写文章

使用GitPage 写文章

文章书写格式有规定按照以下格式进行书写

方式 layout: post 标题 title: gitPage作为博客创建时间 date: 2020-03-12 10:21:00 分类 categories: GitPage 标签 tags: gitPage 作者 author: 阿辉内容标签 * content

微信公众号开发入门

2019-12-19T13:58:00+00:00

申请测试帐号
接入自己的服务器
用户页面授权
发送模板消息
公众号token获取
总结

公司要做微信公众号，又折腾了一遍，总结一下，备忘用

申请测试帐号

个人申请的公众号没有认证的话，是没有那么多权限的，不过微信给我们提供了一个申请测试帐号的页面，申请的测试帐号基本上有所有的权限，申请地址：https://mp.weixin.qq.com/debug/cgi-bin/sandboxinfo?action=showinfo&t=sandbox/index

扫码登录一下，微信就会分配一个测试帐号

接入自己的服务器

官方文档地址：https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Access_Overview.html

我这用springboot启动了一个web服务，提供了一个接口，访问地址为 http://localhost:8080/wechat/，请求类型为GET，根据文档中介绍，微信来验证的时候会传四个参数 signature timestamp nonce echostr

我自己服务器里这个接口拿到这四个参数后，要使用token、timestamp、nonce这三个参数进行校验，成功的话，将参数echostr返回就可以接入成功了

文档中给出的是php的校验方法，我在网上找了一个java的校验类

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * 请求校验工具类
 */
public class SignUtil {

    public static boolean checkSignature(String token, String signature, String timestamp, String nonce) {
        //从请求中（也就是微信服务器传过来的）拿到的token, timestamp, nonce
        String[] arr = new String[]{token, timestamp, nonce};
        // 将token、timestamp、nonce三个参数进行字典序排序
        sort(arr);
        StringBuilder content = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            content.append(arr[i]);
        }
        MessageDigest md = null;
        String tmpStr = null;

        try {
            md = MessageDigest.getInstance("SHA-1");
            // 将三个参数字符串拼接成一个字符串进行sha1加密
            byte[] digest = md.digest(content.toString().getBytes());
            //将字节数组转成字符串
            tmpStr = byteToStr(digest);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }

        content = null;
        // 将sha1加密后的字符串可与signature对比，标识该请求来源于微信
        return tmpStr != null && tmpStr.equals(signature.toUpperCase());
    }

    //将加密后的字节数组变成字符串
    private static String byteToStr(byte[] byteArray) {
        String strDigest = "";
        for (int i = 0; i < byteArray.length; i++) {
            strDigest += byteToHexStr(byteArray[i]);
        }
        return strDigest;
    }

    private static String byteToHexStr(byte mByte) {
        char[] Digit = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
                'B', 'C', 'D', 'E', 'F'};
        char[] tempArr = new char[2];
        tempArr[0] = Digit[(mByte >>> 4) & 0X0F];
        tempArr[1] = Digit[mByte & 0X0F];

        String s = new String(tempArr);
        return s;
    }

    //用于字典排序
    public static void sort(String a[]) {
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = i + 1; j < a.length; j++) {
                if (a[j].compareTo(a[i]) < 0) {
                    String temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
    }
}

接口如下

@GetMapping("/")
public Object callback(String signature, String timestamp, String nonce, String echostr) {
    log.info("signature: {}, timestamp: {}, nonce: {}, echostr: {}", signature, timestamp, nonce, echostr);
    if (SignUtil.checkSignature(siteConfig.getWechat().getToken(), signature, timestamp, nonce)) {
        return ResponseEntity.ok(echostr);
    } else {
        return ResponseEntity.noContent();
    }
}

用户页面授权

公众号文档中的接口很多都要用户的openid，所以有必要在一开始就能拿到用户的openid，这样就可以给用户发消息，模板消息等

页面授权官方文档：https://developers.weixin.qq.com/doc/offiaccount/OA_Web_Apps/Wechat_webpage_authorization.html

就是一套OAuth2协议的授权，这个不多说

用户授权拿到的数据除了openid外，还有access_token,这个token跟公众号的token是不一样的，这个token的作用是拿来调用用户的一些数据的，比如用户的基本信息

另外还有一个接口 https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Get_access_token.html 拿的是公众号的token，这个token的作用是调用公众号的一些接口的，比如给用户发送消息等

注意

如果是测试帐号的话，调用页面授权还要在测试帐号页面上配置一下域名，这个配置的地方有点不太容易发现，位置如下图，把上面接入的个人的服务域名写上就可以了

发送模板消息

官方文档：https://developers.weixin.qq.com/doc/offiaccount/Message_Management/Template_Message_Interface.html

首先要先创建模板消息，如下图

其中 `` 里的内容是固定写法，keyword可以不止3个，可以更多，也可以更少

对应发送接口的数据长下面这个样

{
    "touser":"OPENID",
    "template_id":"ngqIpbwh8bUfcSsECmogfXcV14J0tQlEpBO27izEYtY",
    "url":"http://weixin.qq.com/download",
    "data":{
            "first": {
                "value":"恭喜你购买成功！",
                "color":"#173177"
            },
            "keyword1":{
                "value":"巧克力",
                "color":"#173177"
            },
            "keyword2": {
                "value":"39.8元",
                "color":"#173177"
            },
            "keyword3": {
                "value":"2014年9月22日",
                "color":"#173177"
            },
            "remark":{
                "value":"欢迎再次购买！",
                "color":"#173177"
            }
    }
}

公众号token获取

公众号token最长有效期是2个小时，用于调用公众号的一些接口，一般简单点用个定时器来定时更新即可，不过也可以将token存在一个变量里，每次获取的时候，判断一下token是否过期，过期的话，重新请求更新token，下面是我封装的一个工具，交给spring管理

@Component
@Slf4j
public class WeChatUtil {

    private Date expireTime;
    private String accessToken;

    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private SiteConfig siteConfig;

    public String getAccessToken() {
        if (accessToken == null || DateUtil.isExpire(expireTime)) {
            this.accessToken = null;
            this.fetchAssessToken();
            return accessToken;
        }
        return accessToken;
    }

    private void fetchAssessToken() {
        try {
            String appID = siteConfig.getWechat().getAppID();
            String appsecret = siteConfig.getWechat().getAppsecret();
            String url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=" + appID + "&secret=" + appsecret;
            ResponseEntity<String> forEntity = restTemplate.getForEntity(url, String.class);
            Map body = JSON.parseObject(forEntity.getBody(), Map.class);
            String access_token = (String) body.get("access_token");
            log.info("时间: {}, accessToken: {}", DateUtil.formatDateTime(new Date(), DateUtil.FORMAT_DATETIME), access_token);
            this.expireTime = DateUtil.getHourAfter(new Date(), 1);
            this.accessToken = access_token;
        } catch (RestClientException e) {
            e.printStackTrace();
            log.error("时间：{}，获取accessToken失败！！", DateUtil.formatDateTime(new Date(), DateUtil.FORMAT_DATETIME));
        }
    }
}

用到的工具类

/**
* 判断传入的时间是否在当前时间之后，返回boolean值
* true: 过期
* false: 还没过期
*
* @param date
* @return
*/
public static boolean isExpire(Date date) {
    if (date.before(new Date())) return true;
    return false;
}

总结

有了上面这些就可以做一个 Server酱 了！

springboot集成mybatis配置主从复制双库实现读写分离

2019-10-30T10:26:00+00:00

创建项目
数据
配置
mybatis配置
实体类，mapper
测试
注解实现
再测试

一般情况下网站对数据库的读要比写多多了，所以当数据量大了的时候，使用读写分离是很有必要的

spring提供了数据源路由的类，正好拿它来实现一下

创建项目

简单的springboot项目，依赖有mybatis，mysql，aspect

springboot版本是 2.2.0.RELEASE

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.1</version>
  </dependency>

  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
  </dependency>
</dependencies>

数据

我测试的两个库，一个主库一个从库，只有一个表，数据如下

CREATE TABLE `user` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `username` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- 主库的数据

INSERT INTO `user` (`id`, `username`)
VALUES
	(1, 'tomoya'),
	(2, '阿辉');

-- 从库的数据

INSERT INTO `user` (`id`, `username`)
VALUES
	(1, 'tomoya');

可以看到从库中少了一条数据，这样可以对比看读写分离的功能是否生效了

配置

首先就是springboot的双数据源的配置

application.yml

spring:
  datasource:
    master:
      jdbc-url: jdbc:mysql://192.168.16.87:3306/pybbs?useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai
      username: root
      password: 123123
      driver-class-name: com.mysql.cj.jdbc.Driver
    slave:
      jdbc-url: jdbc:mysql://192.168.16.109:3306/pybbs?useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai
      username: root
      password: 123123
      driver-class-name: com.mysql.cj.jdbc.Driver

使用java代码来创建两个数据源, 创建类 MyDataSource.java

文链接原: https://tomoya92.github.io/2019/10/30/spring-boot-mybatis-read-write-separation/

@Configuration
public class MyDataSource {

  // 主库数据源
  @Bean
  @ConfigurationProperties("spring.datasource.master")
  public DataSource masterDataSource() {
    return DataSourceBuilder.create().build();
  }

  // 从库数据源
  @Bean
  @ConfigurationProperties("spring.datasource.slave")
  public DataSource slaveDataSource() {
    return DataSourceBuilder.create().build();
  }

  // 数据源路由
  @Bean
  public DataSource dynamicDatasource() {
    Map<Object, Object> dataSourceMap = new HashMap<>();
    dataSourceMap.put(MultipleDataSourceHelper.MASTER, masterDataSource());
    dataSourceMap.put(MultipleDataSourceHelper.SLAVE, slaveDataSource());
    DynamicDataSource dds = new DynamicDataSource();
    dds.setTargetDataSources(dataSourceMap);
    dds.setDefaultTargetDataSource(masterDataSource());
    return dds;
  }
}

其中数据源路由是一个自定义的类，继承了spring提供的类AbstractRoutingDataSource，然后实现里面的一个方法determineCurrentLookupKey() 即可，这个方法返回的值就是用哪个数据源

查看类AbstractRoutingDataSource可以看到，里面有两个变量

private Map<Object, Object> targetDataSources;
private Object defaultTargetDataSource;

targetDataSources是一个数据库的map集合，key是自定义的，可以随便指定，value就是配置好的数据源，如下代码

defaultTargetDataSource是默认的数据源，如果指定的key在targetDataSources里没有找到对应的value，那么就会使用这个默认的数据源，防止程序出错

Map<Object, Object> dataSourceMap = new HashMap<>();
dataSourceMap.put(MultipleDataSourceHelper.MASTER, masterDataSource());
dataSourceMap.put(MultipleDataSourceHelper.SLAVE, slaveDataSource());
DynamicDataSource dds = new DynamicDataSource();
dds.setTargetDataSources(dataSourceMap);
dds.setDefaultTargetDataSource(masterDataSource());

既然是一个map，value是数据源，那key最好建一个类管理起来比较好

public class MultipleDataSourceHelper {

  public static final String MASTER = "master";
  public static final String SLAVE = "slave";

  private static ThreadLocal<String> contextHolder = new ThreadLocal<>();

  public static void set(String db) {
    contextHolder.set(db);
  }

  public static String get() {
    return contextHolder.get();
  }

}

实现数据源路由

public class DynamicDataSource extends AbstractRoutingDataSource {

  @Override
  protected Object determineCurrentLookupKey() {
    return MultipleDataSourceHelper.get();
  }
}

可以看到这里动态指定的数据源是从自定义管理key的类中取的，所以要想让CRUD的操作走主库还是从库就只需要改变MultipleDataSourceHelper 里的 contextHolder 就行了

mybatis配置

如果是单数据源，利用spring的配置文件就可以了，也就不用单独对mybatis进行配置了，这里数据源我是自己配置的，所以还要单独配置一下mybatis，给它指定一个数据源，如下

@Configuration
public class MyBatisConfig {

  @Autowired
  private DataSource dynamicDatasource;

  @Bean
  public SqlSessionFactory sqlSessionFactory() throws Exception {
    SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
    // 给mybatis指定上面配置好的动态数据源
    sqlSessionFactoryBean.setDataSource(dynamicDatasource);
    // 自己配置mybatis的话，这个必须要指定mapper位置，在application.yml里配置的不会生效了
    sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*Mapper.xml"));
    return sqlSessionFactoryBean.getObject();
  }
}

如果用application.yml配置的话，只需要在 Mapper 上加一个注解即可 @Mapper 但自己配置的mybatis就要扫包了，在启动类上添加注解 @MapperScan("com.example.multipledatasource.mapper")

有了这个注解，Mapper上的 @Mapper 就不用要了

实体类，mapper

这里我用的实体类mapper跟上一篇博客是一样的，下面再贴一下吧

User.java

public class User {

  private Integer id;
  private String username;

  public Integer getId() {
    return id;
  }

  public void setId(Integer id) {
    this.id = id;
  }

  public String getUsername() {
    return username;
  }

  public void setUsername(String username) {
    this.username = username;
  }

  @Override
  public String toString() {
    return "User{" +
        "id=" + id +
        ", username='" + username + '\'' +
        '}';
  }
}

接文链原: https://tomoya92.github.io/2019/10/30/spring-boot-mybatis-read-write-separation/

UserMapper.java

//@Mapper
public interface UserMapper {

  // 注解方式查询
  @Select("select * from user;")
  List<User> selectAll();

  // xml方式查询
  List<User> selectAllWithXml();

}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.multipledatasource.mapper.UserMapper">
  <resultMap id="baseResultMap" type="com.example.multipledatasource.model.User">
    <result column="id" property="id"/>
    <result column="username" property="username"/>
  </resultMap>

  <select id="selectAllWithXml" resultMap="baseResultMap">
    select *
    from user;
  </select>
</mapper>

测试

@SpringBootTest
public class MultipleDatasourceApplicationTests {

  @Autowired
  private UserMapper userMapper;

  @Test
  void contextLoads() {
    // 指定使用主库
    MultipleDataSourceHelper.set(MultipleDataSourceHelper.MASTER);
    List<User> users = userMapper.selectAll();
    for (User user : users) {
      System.out.println(user.toString());
    }

    System.out.println("=========================");

    // 指定使用从库
    MultipleDataSourceHelper.set(MultipleDataSourceHelper.SLAVE);
    List<User> users1 = userMapper.selectAllWithXml();
    for (User user : users1) {
      System.out.println(user.toString());
    }
  }

}

结果

2019-10-30 10:47:07.438  INFO 26478 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2019-10-30 10:47:07.644  INFO 26478 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
User{id=1, username='tomoya'}
User{id=2, username='阿辉'}
=========================
2019-10-30 10:47:07.691  INFO 26478 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-2 - Starting...
2019-10-30 10:47:07.738  INFO 26478 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-2 - Start completed.
User{id=1, username='tomoya'}

注解实现

这样手动设置比较麻烦，可以自定义一个注解，在读的方法的上通过注解指定从库查询，在写的方法上使用注解指定写入主库

spring两大思想中的aop可以实现这个功能，首先创建一个切入点类

public class DSPointcut {

  @Pointcut("execution(public * com.example.multipledatasource.mapper.*.*(..))")
  public void selectorDSPointcut() {
  }
}

有了切入点了，还少了注解，下面自定义一个注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DSSelector {

  String value();

}

在UserMapper.java类里的两个方法上加上相应的注解

//@Mapper
public interface UserMapper {

  // 注解方式查询
  @Select("select * from user;")
  @DSSelector(MultipleDataSourceHelper.MASTER) // 指定从主库查询
  List<User> selectAll();

  // xml方式查询
  @DSSelector(MultipleDataSourceHelper.SLAVE) // 指定从从库查询
  List<User> selectAllWithXml();

}

我这写的是两个查询方法，当然也可以是插入，更新，删除，只需要一个注解指定一下就行了

有了注解，有了切入点了，下面就是切入mapper方法执行前去获取这个方法上的注解信息了，然后再去设置MultipleDataSourceHelper，这样就可以实现自动了，代码如下

@Component
@Aspect
public class DSSelectorImpl {

  @Before("com.example.multipledatasource.aspect.DSPointcut.selectorDSPointcut()")
  public void changeDS(JoinPoint joinPoint) {
    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    Method method = signature.getMethod();
    DSSelector selector = method.getAnnotation(DSSelector.class);
    if (selector == null) return;
    MultipleDataSourceHelper.set(selector.value());
  }
}

再测试

@SpringBootTest
@EnableAspectJAutoProxy
public class MultipleDatasourceApplicationTests {

  @Autowired
  private UserMapper userMapper;

  @Test
  void contextLoads() {
    List<User> users = userMapper.selectAll();
    for (User user : users) {
      System.out.println(user.toString());
    }

    System.out.println("=========================");

    List<User> users1 = userMapper.selectAllWithXml();
    for (User user : users1) {
      System.out.println(user.toString());
    }
  }

}

日志

2019-10-30 10:56:11.895  INFO 26991 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2019-10-30 10:56:12.120  INFO 26991 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
User{id=1, username='tomoya'}
User{id=2, username='阿辉'}
=========================
2019-10-30 10:56:12.167  INFO 26991 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-2 - Starting...
2019-10-30 10:56:12.211  INFO 26991 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-2 - Start completed.
User{id=1, username='tomoya'}

跟手动指定的结果是一样的

springboot项目集成mybatis

2019-10-29T14:52:00+00:00

创建项目
数据库配置
实体类mapper
测试

之间写过一篇最全的Spring-Boot集成Mybatis-Plus教程

突然发现不会配置单纯的mybatis了，稍微折腾了一下

创建项目

创建springboot项目，只选择mybatis和mysql两个依赖

pom.xml

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.1</version>
  </dependency>

  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>

数据库配置

数据源配置

spring:
  datasource:
    url: jdbc:mysql://192.168.16.87:3306/pybbs?useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: 123123

表结构及数据

CREATE TABLE `user` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `username` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

表数据

INSERT INTO `user` (`id`, `username`)
VALUES
	(1, 'tomoya'),
	(2, '阿辉');

实体类mapper

User.java

public class User {

  private Integer id;
  private String username;

  public Integer getId() {
    return id;
  }

  public void setId(Integer id) {
    this.id = id;
  }

  public String getUsername() {
    return username;
  }

  public void setUsername(String username) {
    this.username = username;
  }

  @Override
  public String toString() {
    return "User{" +
        "id=" + id +
        ", username='" + username + '\'' +
        '}';
  }
}

文链接原: https://tomoya92.github.io/2019/10/29/spring-boot-mybatis/

UserMapper.java

@Mapper
public interface UserMapper {

  // 注解方式查询
  @Select("select * from user;")
  List<User> selectAll();

  // 注解带参数方式 通过 ${} 接收参数
  @Delete("delete from user where username = '${username}'")
  void deleteByUsername(@Param("username") String username);

  // 使用 #{} 接收参数，如果是单一的参数可以不用加 @Param 注解，如果是对象或者多个参数，就需要加上 @Param 注解
  @Select("select * from user where id = #{user.id}")
  void selectById(@Param("user") User user);
  @Select("select * from user where id = #{user.id} and username = #{username}")
  void selectByIdAndUsername(@Param("id") Integer id, @Param("username") String username);

  // xml方式查询
  List<User> selectAllWithXml();

}

如果使用 ${} 接收字符串参数，还需要在外面加上引号 ‘${xxx}’ 如果是 #{} 接收字符串参数则可以不用加引号

UserMapper.xml 注意：这个xml文件我放在了 src/resources/mapper/UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.multipledatasource.mapper.UserMapper">
  <resultMap id="baseResultMap" type="com.example.multipledatasource.model.User">
    <result column="id" property="id"/>
    <result column="username" property="username"/>
  </resultMap>

  <select id="selectAllWithXml" resultMap="baseResultMap">
    select *
    from user;
  </select>
</mapper>

最后配置启动时扫描 *Mapper.xml 文件

application.yml

mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml

测试

@SpringBootTest
public class MultipleDatasourceApplicationTests {

  @Autowired
  private UserMapper userMapper;

  @Test
  void contextLoads() {
    List<User> users = userMapper.selectAll();
    for (User user : users) {
      System.out.println(user.toString());
    }

    System.out.println("=========================");

    List<User> users1 = userMapper.selectAllWithXml();
    for (User user : users1) {
      System.out.println(user.toString());
    }
  }

}

运行结果

User{id=1, username='tomoya'}
User{id=2, username='阿辉'}
=========================
User{id=1, username='tomoya'}
User{id=2, username='阿辉'}

MySQL主从复制（主主复制）配置

2019-10-24T10:21:00+00:00

安装mysql
开启bin-log日志
配置用于同步的用户
在从节点开启同步
主主复制

mysql自带的就有主从复制功能，原理是通过主节点的bin-log日志来实现的数据同步

master开启bin-log日志 -> slave开启同步日志 -> slave读取master的bin-log中的sql语句达到同步数据的功能

安装mysql

既然要做主从复制，就先要有两台服务器，并在每台服务器上安装好mysql服务，这里省略

我这里安装好的两台服务器的ip分别是 192.168.16.87 192.168.16.109 下面可能会用到，请根据自己的ip自行修改一些sql语句

开启bin-log日志

master

修改mysql的配置文件

$ sudo vim /etc/mysql/mysql.cond.d/mysqld.conf

将如下两行注释去掉保存即可

server-id = 1
log_bin = /var/log/mysql/mysql-bin.log

重启mysql服务，登录mysql后运行

show variables like '%log_bin%';

可以看到bin-log的开启是否成功

链接文原: https://tomoya92.github.io/2019/10/24/mysql-master-slave/

slave

然后配置从节点

同样的打开mysql的配置文件，添加下面三行配置

server-id = 2
relay-log = /var/log/mysql/relay-bin.log
relay-log-index = /var/log/mysql/relay-bin.index

其中 server-id 一定不能跟主节点的重复

重启服务

配置用于同步的用户

开启了bin-log，然后配置一个用户用于同步这些日志

这个用户配置在主节点上，因为从节点要连主节点读取日志信息，所以这个用户就需要主节点来提供

创建用户并赋予权限，用户名sync_db

> create user 'sync_db'@'%' identified by '123123';
> grant replication slave on *.* to 'sync_db'@'%' identified by '123123';

在从节点开启同步

主节点有了用户，就可以在从节点开启同步功能了

登录mysql，运行下面命令开启同步功能

> change master to master_host = '192.168.16.87', master_port=3306, master_user='sync_db', master_password='123123', master_log_file='mysql-bin.000001', master_log_pos=0;
> start slave;

关闭同步

> stop slave;

查看同步开启状态

> show slave status;

如果看到下图中两个字段都是YES了，就说明开启成功了

这时候在主节点上创建数据库，添加数据，创建表等操作都会被自动的同步到从节点上的mysql数据库中

主主复制

主主复制就是将主从复制返过来，在上面配置的从节点中开启bin-log日志，然后在主节点同步从库的bin-log达到同步数据的目的

与主从复制的区别：主从复制中当从库数据有变动时，主库里数据不会变，主主复制不管哪一个库发生了变动，数据始终都会保持一致

nginx用法总结，映射静态资源，代理http，负载均衡，tcp服务，附带 haproxy 简单配置

2019-10-12T16:59:00+00:00

安装
映射静态文件
代理网站（http代理）
nginx负载均衡
tcp代理
haproxy负载均衡

用nginx也有好多年了，还没有总结过，这篇博客总结一下

安装

我测试环境是在mac，平时用的服务器有ubuntu和centos

# mac
brew install nginx

# ubuntu
apt install nginx

# centos
yum install nginx

启动，重启服务

# mac
brew services start/restart/reload nginx

# ubuntu
service nginx start/restart/reload

# centos
systemctl start/restart/reload nginx.service

映射静态文件

nginx启动就会接管服务器上的80端口，所以如果服务器上有80端口的服务，会启动失败，解决办法就是停了它们或者卸载它们，比如另一个服务器 apache，它也是占用80端口的

一般正常情况都是使用不同的域名解析到一个服务器上，然后通过nginx来实现不同服务之间的转发

我这里以修改hosts来实现域名的解析

127.0.0.1 demo.com

在电脑上创建一个文件夹，里面放上一张图片，然后配置nginx，配置文件在

# mac
/usr/local/etc/nginx

# ubuntu/centos
/etc/nginx

一般nginx都会有个默认的配置文件 nginx.conf 在里面可以找到这样一段 include servers/*; 或者 linux系统上就是 include conf.d/*;

这样我就可以把nginx的配置文件写在它包含进去的文件夹里了，mac上装好nginx后，在/usr/local/etc/nginx里没有 servers 目录，可以自己创建一个，nginx的配置文件一般都是以 .conf 结尾

在 servers 里新建一个文件 demo.conf 名字随便取，添加上下面配置

server {
    listen 80;
    server_name demo.com;
    location / {
        root /Users/hh/Desktop/static;
    }
}

其中 /Users/hh/Desktop/static 就是我放图片的静态文件目录，重新加载nginx

brew services reload nginx

浏览器访问 http://demo.com/0.png 即可打开图片

既然nginx可以映射静态资源文件，那前端框架写的项目打包后可不可以用它映射成服务呢？

是可以的，但如果有框架里用到了前端路由，就会有问题（没记错的话要么是404，要么是返回报错），这时候稍微加一些配置就可以解决了

server {
    listen 80;
    server_name demo.com;
    location / {
        root /Users/hh/Desktop/react-demo/build;
        index index.html;
        autoindex on;
        set $fallback_file /index.html;
        if ($http_accept !~ text/html) {
            set $fallback_file /null;
        }
        if ($uri ~ /$) {
            set $fallback_file $uri;
        }
        try_files $uri $fallback_file;
    }
}

重启nginx服务，再次访问就没有什么问题了

代理网站（http代理）

使用nodejs中的 serve 模块启动一个http服务

serve -l 3000 /Users/hh/Desktop/nginx-demo/demo

文链接原: https://tomoya92.github.io/2019/10/12/nginx-tutorial/

在 /Users/hh/Desktop/nginx-demo/demo 目录下我创建了一个 index.html 文件，内容

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>Document demo</title>
  </head>
  <body>
    hello world! demo.com
  </body>
</html>

配置nginx，可以在上一个 demo.conf 文件里继续配置，也可以自己再新建一个配置文件，这里还用的是 demo.com 这个域名，先把映射静态文件的配置注释掉

server {
    listen 80;
    server_name demo.com;
    location / {
        proxy_pass http://localhost:3000;
    }
}

重新加载nginx，然后浏览器访问：http://demo.com 即可看见 index.html 的内容

nginx负载均衡

使用场景：

一台服务器性能不够，要增加服务器
不停服部署

说白了就是一个请求交由nginx根据负载均衡的配置来分发到不同的服务器上进行业务处理，举个例子

我这启动了两个服务，端口分别是 3000, 3001

两个页面分别是

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>Document demo</title>
  </head>
  <body>
    hello world! demo.com
  </body>
</html>

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>Document demo</title>
  </head>
  <body>
    hello world! demo1.com
  </body>
</html>

将之间的配置注释掉，修改nginx的配置

upstream demo_server {
    server 127.0.0.1:3000 weight=3;
    server 127.0.0.1:3001 weight=7;
}
server {
    listen 80;
    server_name demo.com;
    location / {
        proxy_pass http://demo_server;
    }
}

我这里把 3000 端口的服务权重定为3，3001的权重定为 7，然后重启nginx，访问 http://demo.com 一直刷新页面，大概10次里会有3次出现3000端口的页面，7次是3001服务的页面内容

tcp代理

tcp代理配置文件的位置稍微不同，找到 nginx.conf 文件，找到 include servers/*; 然后看它外面还有一层 http {} 说明nginx默认是代理http的服务，要想代理tcp的服务就要将配置写在与 http{} 同级的地方，我就直接写在 nginx.conf 里了，然后将本机上装的mysql服务映射成 demo.com 域名访问

配置如下

stream {
    server {
        listen 80;
        proxy_pass 127.0.0.1:3306;
    }
}

重新加载nginx

通过mysql客户端工具，可以直接使用域名连接mysql了

tcp也能代理，这就好玩了，各种联机游戏都可以通过nginx来转发了，简直爽歪歪

haproxy负载均衡

haproxy天生就自带负载均衡

ubuntu安装

sudo apt install haproxy

编辑haproxy的配置文件 /etc/haproxy/haproxy.cfg

listen
  mode tcp
  bind 0.0.0.0:3307  # 这端口换一下，为了测试
  server s1 192.168.16.87:3306
  server s2 192.168.16.109:3306

改好后保存，然后重启haproxy服务 service haproxy restart

连接mysql，重复连接几次会发现连接的服务是在 192.168.16.87和192.168.16.109之间来回的换

MySQL存储过程学习, java调用存储过程总结

2019-09-27T14:14:00+00:00

变量声明赋值
存储过程创建
逻辑循环
传值
应用

了解一下mysql的存储过程用法，总结一下

变量声明赋值

关键字 declare

-- 定义一个name变量，类型为 varchar

declare name varchar(20);

赋值关键字 set

-- 定义一个name变量，类型为 varchar

declare name varchar(20);
set name = "tomcat";

存储过程创建

格式如下

DELIMITER //
create procedure my_first_procedure()
begin
	-- 这里是要编写的逻辑
end
//

比如上面定义的name，现在要赋值并查询出来

DELIMITER //
create procedure my_first_procedure()
begin
	declare name varchar(20);
	set name = "tomcat";
	select name;
end
//

先执行存储过程，让mysql将存储过程创建好

删除存储过程

drop procedure my_first_procedure;

然后再使用 call 关键字调用存储过程

call my_first_procedure();

再执行调用语句结果如下

逻辑循环

if语句格式

if (condition) then
  -- do something...
end if;

if else

if condition then
  -- do something...
else
  -- do something...
end if;

if elseif

if condition then
  -- do something...
elseif condition then
  -- do something...
else
  -- do something...
end if;

注意end if后面的分号，以及每个条件中语句的分号结束

case when

declare name varchar(20);
set name = "tomcat";
case name
  when "tomcat" then
    select "tomcat";
  when "jetty" then
    select "jetty";
end case;

while do循环

while condition do
  // do something...
end while;

例：

链接文原: https://tomoya92.github.io/2019/09/27/mysql-procedure/

DELIMITER //
create procedure my_first_procedure()
begin
	declare age int;
	declare sum int;
	set age = 1;
	set sum = 0;
	while age < 100 do
		set sum = sum + age;
		set age = age + 1;
	end while;
	select sum;
end
//

-- 如果存储过程已经存在了，先删除再创建
drop procedure my_first_procedure;

call my_first_procedure();

repeat until

repeat
  // do something...
until condition
end repeat;

例子

DELIMITER //
create procedure my_first_procedure()
begin
	declare age int;
	declare sum int;
	set age = 1;
	set sum = 0;
	repeat
		set age = age + 1;
		set sum = sum + age;
	until age > 100
	end repeat;
	select sum;
end
//

drop procedure my_first_procedure;

call my_first_procedure();

loop 循环

结构

loopName:loop
  if condition then
    leave loopName;
  end if;
  // do something...
end loop;

例子

DELIMITER //
create procedure my_first_procedure()
begin
	declare age int;
	declare sum int;
	set age = 1;
	set sum = 0;
	loopName:loop
		if age > 100 then
			leave loopName;
		end if;
		set age = age + 1;
		set sum = sum + age;
	end loop;
	select sum;
end
//

drop procedure my_first_procedure;

call my_first_procedure();

传值

对存储过程传值

有两个关键字 in out

in 是往存储过程中传值，如下例子

drop procedure my_first_procedure;

DELIMITER //
create procedure my_first_procedure(in age int)
begin
	if age < 10 then
		select "children";
	else
		select "other";
	end if;
end
//

-- declare age int;
set @age = 11;
call my_first_procedure(@age);

这里用declare关键字声明一个变量传到存储过程中会有问题，所以改用@声明变量

out是在存储过程中处理的结果返回出来用的, 使用中要配合着 into 关键字使用

用法

文链接原: https://tomoya92.github.io/2019/09/27/mysql-procedure/

drop procedure my_first_procedure;

DELIMITER //
create procedure my_first_procedure(in age int, out name varchar(20))
begin
	if age < 10 then
		select "children" into name;
	else
		select "other" into name;
	end if;
end
//

-- declare age int;
set @age = 11;
set @name = "";
call my_first_procedure(@age, @name);
select @name;

应用

在java程序中调用存储过程之间，要先将存储过程在mysql中创建好，我这里以下面这个存储过程为例

DELIMITER //
create procedure myFirstProcedure()
begin
	select * from user;
end
//

创建maven项目，引入依赖

<dependencies>
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.48</version>
	</dependency>
</dependencies>

<build>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>3.8.1</version>
			<configuration>
				<source>1.8</source>
				<target>1.8</target>
				<encoding>UTF-8</encoding>
				<showWarnings>true</showWarnings>
			</configuration>
		</plugin>
	</plugins>
</build>

创建测试类，代码如下

import java.sql.*;

/**
 * Created by tomoya at 2019/9/30
 */
public class Main {

  public Main() throws SQLException {
    Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/pybbs", "root", "");
    CallableStatement cs = connection.prepareCall("{call mySecondProcedure()}");
    cs.execute();
    ResultSet resultSet = cs.getResultSet();
    while (resultSet.next()) {
      Integer id = resultSet.getInt("id");
      String username = resultSet.getString("username");
      System.out.println("id: " + id + " username: " + username);
    }
  }

  public static void main(String[] args) throws SQLException {
    new Main();
  }
}

看起来跟java连接jdbc调用查询是一样的，最后都是从ResultSet里取数据

参数也是一样的传法，看下面这个存储过程

DELIMITER //
create procedure mySecondProcedure(in myId int)
begin
	select * from user where id = myId;
end
//

调用程序

import java.sql.*;

/**
 * Created by tomoya at 2019/9/30
 */
public class Main {

  public Main() throws SQLException {
    Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/pybbs", "root", "");
    CallableStatement cs = connection.prepareCall("{call mySecondProcedure(?)}"); // 存储过程中有多少参数这里就有几个 ?
    cs.setInt(1, 10);// 查询id为10的用户信息, 参数下标是从1开始的
    cs.execute();
    ResultSet resultSet = cs.getResultSet();
    while (resultSet.next()) {
      Integer id = resultSet.getInt("id");
      String username = resultSet.getString("username");
      System.out.println("id: " + id + " username: " + username);
    }
  }

  public static void main(String[] args) throws SQLException {
    new Main();
  }
}

springboot前后端分离项目中使用hibernate-validator校验请求参数返回自定义异常信息的json数据

2019-09-11T16:02:00+00:00

创建项目
简单使用
统一异常处理
常用校验注解
异常分别处理
对象校验
总结

之间整理过一篇 springboot 项目里使用 hibernate-validator 校验参数，然后在freemarker模板里取异常信息展示的博客

现在都流行前后端分离了，服务端大都直接返json，又稍微折腾了一下，结合统一异常处理，优雅的实现请求参数的校验

创建项目

这个不多说，引入一个依赖即可

<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.0.17.Final</version>
</dependency>

简单使用

使用 hibernate-validator 分两步

在controller类上加上 @Validated 注解
在controller里方法的参数前加上相应的校验注解，比如 @NotNull

简单例子

import com.example.hibernatevalidator.util.Result;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.constraints.NotNull;

/**
 * Created by tomoya at 2019/9/11
 */
@RestController
@RequestMapping("/")
@Validated
public class IndexController {

  @GetMapping("/index")
  public Object index(@NotNull(message = "姓名不能为空") String name) {
    return Result.success("你好，" + name);
  }
}

可以看到 @NotNull 注解是 javax.validation.constraints 这个包下的，后面介绍的一些校验注解都是这个包下的，可见hibernate-validator是实现的java的api

然后启动项目，浏览器访问 http://localhost:8080/index 可以看到出现了下面这个错误页面

这个页面是springboot内置的错误页面

项目都前后端分离了，错误信息肯定最好也用json返回了，其实这时候如果用postman这样的工具来访问这个接口返回的就是一段json，长下面这个样

{
  "timestamp": "2019-09-11T07:42:56.703+0000",
  "status": 500,
  "error": "Internal Server Error",
  "message": "index.name: 姓名不能为空",
  "path": "/index"
}

就算是这个样也不是我想要的，项目里封装了一个类，专门返回json的，长这个样

public class Result {

  private int code;
  private String description;
  private Object detail;

  public static Result success(Object detail) {
    Result result = new Result();
    result.setCode(200);
    result.setDetail(detail);
    return result;
  }

  public static Result error(String description) {
    Result result = new Result();
    result.setCode(201);
    result.setDescription(description);
    return result;
  }

  // getter setter
}

怎么才能让hibernate-validator校验的异常信息以自己定义的类的格式返回呢？这就要用到统一异常处理了

链接文原: https://tomoya92.github.io/2019/09/11/spring-boot-hibernate-validator-json/

统一异常处理

springmvc是相当的强大的，只需要两个注解就能使用统一异常处理 @ControllerAdvice 外加上 @ExceptionHandler

import com.example.hibernatevalidator.util.Result;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice
public class GlobalExceptionHandler {

  @ExceptionHandler(value = Exception.class)
  @ResponseBody
  public Result defaultErrorHandler(Exception e) {
    System.out.println(e.getMessage());
    return Result.error(e.getMessage());
  }
}

这时候再用浏览器访问就可以看到返回的是一段json字符串了

常用校验注解

@NotNull 只能判断是null的参数
@NotBlank 可以判断null和空字符串
@Email 校验参数是否是标准的email格式
@URL 判断参数是否是一个正常的url地址
@Max 判断一个数字最大值是多少，超过抛出异常
@Min 与 @Max相反
@Size 指定一个字符串的长度范围，包含最小和最大
@Pattern 自定义正则校验参数

一个参数可以有多个校验注解来修饰

import com.example.hibernatevalidator.util.Result;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.constraints.*;

/**
 * Created by tomoya at 2019/9/11
 */
@RestController
@RequestMapping("/")
@Validated
public class IndexController {

  @GetMapping("/index")
  public Object index(@NotBlank(message = "姓名不能为空") String name,
                      @NotNull(message = "age1不能为空") @Max(value = 12, message = "最大为12") Integer age1,
                      @NotNull(message = "age2不能为空") @Min(value = 6, message = "最小为6") Integer age2,
                      @NotNull(message = "address不能为空") @Size(min = 6, max = 20, message = "范围要在[6,20]之间") String address,
                      @NotNull(message = "password不能为空") @Pattern(regexp = "[a-zA-Z0-9]{4,16}$", message = "密码为字母+数字组合4-16位") String password) {
    return Result.success("你好，" + name);
  }
}

访问浏览器 http://localhost:8080/index 输出的json长下面这个样

{
  "code": 201,
  "description": "index.address: address不能为空, index.age1: age1不能为空, index.password: password不能为空, index.age2: age2不能为空, index.name: 姓名不能为空"
}

异常分别处理

它是把错误信息都拼在一块输出的，这样在前端不好展示的，可以通过 : 和 , 将字符串分隔成前端想要的格式再返回，这个在统一异常处理那做就可以了

但这又会出一个问题，一个项目里用上了统一异常处理后，可不止校验这一个地方会出现异常，如果只是简单的使用 e.getMessage() 将异常信息拿出来进行分隔，肯定会出问题的，因为如果是空指针异常的话 e.getMessage() 取出来的是个null，这时候再进行 split() 肯定又会报错的

解决办法就是根据异常类来进行区分，通过断点可以发现 hibernate-validator 校验的异常类是 javax.validation.ConstraintViolationException

这样就可以做文章了，代码如下

@ControllerAdvice
public class GlobalExceptionHandler {

  @ExceptionHandler(value = Exception.class)
  @ResponseBody
  public Result defaultErrorHandler(Exception e) {
    System.out.println(e.getMessage());
    if (e instanceof ConstraintViolationException) {
      ConstraintViolationException constraintViolationException = (ConstraintViolationException) e;
      String message = StringUtils.collectionToCommaDelimitedString(
          constraintViolationException.getConstraintViolations()
              .stream()
              .map(ConstraintViolation::getMessage)
              .collect(Collectors.toList()));
      return Result.error(message);
    }
    return Result.error("服务异常");
  }
}

再次访问异常信息就长下面这个样了

{
  "code": 201,
  "description": "age2不能为空,address不能为空,age1不能为空,password不能为空,姓名不能为空"
}

这只是一种分隔方法，可以自己定义自己的封装方式

对象校验

如果一个方法的参数相当的多，也可以将其封装在一个对象中，然后对这个对象进行校验，对象代码如下

文链接原: https://tomoya92.github.io/2019/09/11/spring-boot-hibernate-validator-json/

import javax.validation.constraints.*;

/**
 * Created by tomoya at 2019/9/11
 */
public class User {

  @NotBlank(message = "姓名不能为空")
  private String name;

  @NotNull(message = "age1不能为空")
  @Max(value = 12, message = "最大为12")
  private Integer age1;

  @NotNull(message = "age2不能为空")
  @Min(value = 6, message = "最小为6")
  private Integer age2;

  @NotNull(message = "address不能为空")
  @Size(min = 6, max = 20, message = "范围要在[6,20]之间")
  private String address;

  @NotNull(message = "password不能为空")
  @Pattern(regexp = "[a-zA-Z0-9]{4,16}$", message = "密码为字母+数字组合4-16位")
  private String password;

  // getter setter
}

controller方法里参数也要换成对象，注解也变了

@GetMapping("/index1")
public Object index1(@Valid User user) {
  return Result.success("你好，" + user.getName());
}

访问浏览器，输出json如下

{
  "code": 201,
  "description": "服务异常"
}

这一看就不对，不是上面封装的异常处理信息，断点查看原来对对象进行校验异常类变成了 org.springframework.validation.BindException

知道是哪个异常类就好办了，另外对这个异常类也做一下处理即可

@ControllerAdvice
public class GlobalExceptionHandler {

  @ExceptionHandler(value = Exception.class)
  @ResponseBody
  public Result defaultErrorHandler(Exception e) {
    System.out.println(e.getMessage());
    if (e instanceof ConstraintViolationException) {
      ConstraintViolationException constraintViolationException = (ConstraintViolationException) e;
      String message = StringUtils.collectionToCommaDelimitedString(
          constraintViolationException.getConstraintViolations()
              .stream()
              .map(ConstraintViolation::getMessage)
              .collect(Collectors.toList()));
      return Result.error(message);
    } else if (e instanceof BindException) {
      BindException bindException = (BindException) e;
      String message = StringUtils.collectionToCommaDelimitedString(
          bindException.getAllErrors()
              .stream()
              .map(DefaultMessageSourceResolvable::getDefaultMessage)
              .collect(Collectors.toList())
      );
      return Result.error(message);
    }
    return Result.error("服务异常");
  }
}

再次访问输出json

{
  "code": 201,
  "description": "姓名不能为空,age2不能为空,address不能为空,age1不能为空,password不能为空"
}

异常信息再次正常了

总结

hibernate-validator还是比较好用的，比在controller里一个参数一个参数的去判断要好看的多，但它也有个问题，如果一个请求方法里参数相当的多，就会想着去封装对象，这样看着也好看，但如果参数很多的方法非常多的话，就要多封装很多这样的对象，也就大大增加了项目中实体类的数量，这个我个人不太喜欢，所以不是太多的方法我一般都是直接写在controller方法的参数里的

spring-boot 项目利用spring切面实现插件功能，对项目无侵入

2019-07-02T16:40:00+00:00

创建项目
配置
增加切入点
切入
测试
加载

开发pybbs时，一直想加入插件功能，但没有比较好用的实现方法，突然有一天想起来spring里的切面了，这不正是写插件的好东西，然后就折腾了一下，总结一下

最可怕的是，在拿到参数和返回值之后，还可以进行修改，修改完后，再返回回去，神不知鬼不觉！！

创建项目

首先创建springboot项目，最简单的就行，我这就引了一个依赖

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
  </dependency>

  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
  </dependency>

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>

配置

首先开启 aspect 功能

@SpringBootApplication
@EnableAspectJAutoProxy
public class PluginDemoApplication {

  public static void main(String[] args) {
    SpringApplication.run(PluginDemoApplication.class, args);
  }

}

然后编写 model, service

User.java

@Data
@ToString
public class User {

  private Integer id;
  private String username;

}

UserService.java

@Service
@Slf4j
public class UserService {

  public User save(User user) {
    log.info("save user: " + user.toString());
    return user;
  }

  public void delete(Integer id) {
    log.info("user deleted!");
  }

}

增加切入点

创建切入点，固定写法

UserServicePointcut.java

public class UserServicePointcut {

  @Pointcut("execution(public * com.example.plugindemo.service.UserService.save(..))")
  public void save() {
  }

  @Pointcut("execution(public * com.example.plugindemo.service.UserService.delete(..))")
  public void delete() {
  }

}

文原接链: https://tomoya92.github.io/2019/07/02/spring-boot-plugin/

切入

从上面提供的切入点来切入相应的服务，可以拿到 service 里方法的参数，返回值等信息，而且原service方法还不知道

切入有三种方式

@Before 在被切入方法执行前执行
@After 在被切入方法执行后执行
@Around 在被切入方法执行过程中执行

我这里以一个redis的缓存来实现两个功能

当添加用户时，将用户缓存进redis里
当删除用户时，再从redis里将用户删除

UserPlugin.java

@Component
@Aspect
@Slf4j
public class RedisPlugin {

  @Around("com.example.plugindemo.plugin.UserServicePointcut.save()")
  public Object save(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    // 获取参数
    Object[] args = proceedingJoinPoint.getArgs();
    log.info(args[0].toString());
    // 修改参数内容
    ((User) args[0]).setUsername("jetty");
    // 通过 proceed 方法执行被切入方法然后再返回，如果要修改内容也可以在拿到执行完后的对象进行修改，修改完后再返回
    return proceedingJoinPoint.proceed(args);
  }

  @After("com.example.plugindemo.plugin.UserServicePointcut.save()")
  public void afterSave(JoinPoint joinPoint) {
    // 获取参数
    Object[] args = joinPoint.getArgs();
    log.info("将 user 对象缓存进 redis 里, user: {}", args[0].toString());
  }

  @Before("com.example.plugindemo.plugin.UserServicePointcut.delete()")
  public void delete(JoinPoint joinPoint) {
    // 获取参数
    Object[] args = joinPoint.getArgs();
    log.info("将 redis 里的user对象删除，根据id: {}", args[0]);
  }
}

测试

测试代码如下

PluginDemoApplicationTests.java

@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class PluginDemoApplicationTests {

  @Autowired
  private UserService userService;

  @Test
  public void save() {
    User user = new User();
    user.setUsername("tomcat");
    user.setId(1);
    user = userService.save(user);
    log.info(user.toString());
  }

  @Test
  public void delete() {
    userService.delete(1);
  }

}

接文原链: https://tomoya92.github.io/2019/07/02/spring-boot-plugin/

上面例子中对 save() 方法进行了两个切入，执行日志如下

2019-07-02 17:30:30.682  INFO 21254 --- [           main] c.example.plugindemo.plugin.RedisPlugin  : User(id=1, username=tomcat)
2019-07-02 17:30:30.689  INFO 21254 --- [           main] c.e.plugindemo.service.UserService       : save user: User(id=1, username=jetty)
2019-07-02 17:30:30.689  INFO 21254 --- [           main] c.example.plugindemo.plugin.RedisPlugin  : 将 user 对象缓存进 redis 里, user: User(id=1, username=jetty)
2019-07-02 17:30:30.691  INFO 21254 --- [           main] c.e.p.PluginDemoApplicationTests         : User(id=1, username=jetty)

在调用 delete() 方法后日志如下

2019-07-02 17:31:10.582  INFO 21256 --- [           main] c.example.plugindemo.plugin.RedisPlugin  : 将 redis 里的user对象删除，根据id: 1
2019-07-02 17:31:10.590  INFO 21256 --- [           main] c.e.plugindemo.service.UserService       : user deleted!

加载

springboot项目打包后是个jar包，可以通过 java -jar xx.jar 来执行

那有没有可能将插件分出来开发，然后打成jar包，在启动主项目时，指定一下目录就默认自动加载了呢？

答案是有的

首先修改打包插件

pom.xml

<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <configuration>
    <layout>ZIP</layout>
  </configuration>
</plugin>

这样再打包的主项目通过下面脚本启动就可以加载指定目录下的插件jar包了

将插件jar包放在主项目jar包同目录下的 plugins 下，然后启动脚本里加上加载路径

`java -Dloader.path=./plugins -jar xx.jar`

总结一下spring中的JdbcTemplate的CRUD用法

2019-05-31T18:03:00+00:00

jpa做的项目，当条件查询多起来，还不固定的时候，查询方法就不好写了，又不好改成mybatis，那么JdbcTemplate将是个不错的选择

表结构

CREATE TABLE `book` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `category` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

对应的实体类

public class Book implements Serializable {

    private Integer id;
    private String name;
    private String category;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCategory() {
        return category;
    }

    public void setCategory(String category) {
        this.category = category;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", category='" + category + '\'' +
                '}';
    }
}

我这环境是spring-boot项目，依赖如下

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

文原接链: https://tomoya92.github.io/2019/05/31/spring-jdbc-template/

CRUD 用法

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class JdbctemplateDemoApplicationTests {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    // 保存数据
    @Test
    public void save() {
        String sql = "insert into book (name, category) values (?, ?)";
        int update = jdbcTemplate.update(sql, "Spring", "java");
        System.out.println(update);
    }

    // 批量保存数据
    @Test
    public void batchSave() {
        String sql = "insert into book (name, category) values (?, ?)";
        List<Object[]> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            Object[] objects = new Object[2];
            objects[0] = "Spring" + i;
            objects[1] = "java";
            list.add(objects);
        }
        int[] update = jdbcTemplate.batchUpdate(sql, list);
        for (int i = 0; i < update.length; i++) {
            System.out.println(update[i]);
        }
    }

    // 根据条件更新
    @Test
    public void update() {
        String sql = "update book set category = ? where name = ?";
        int update = jdbcTemplate.update(sql, "Java", "Spring");
        System.out.println(update);
    }

    // 批量更新
    @Test
    public void batchUpdate() {
        String sql = "update book set category = ? where name = ?";
        List<Object[]> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            Object[] objects = new Object[2];
            objects[0] = "Java";
            objects[1] = "Spring" + i;
            list.add(objects);
        }
        int[] update = jdbcTemplate.batchUpdate(sql, list);
        for (int i = 0; i < update.length; i++) {
            System.out.println(update[i]);
        }
    }

    // 根据id查询book对象
    @Test
    public void queryForObject() {
        String sql = "select * from book where id = ?";
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Book.class), 1);
        System.out.println(book);
    }

    // 查询数量
    @Test
    public void queryForInt() {
        String sql = "select count(1) from book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println(count);
    }

    // 查询返回列表（定义好的bean）
    // 如果不指定new BeanPropertyRowMapper<>(Book.class)则返回List<Map<String, Object>>格式的数据
    @Test
    public void queryForList() {
        String sql = "select * from book where category = ?";
        // queryForList() 方法没法返回自定义的bean列表，不过用这个query方法可以
        List<Book> books = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Book.class), "Java");
        System.out.println(books);
    }

    // 根据id删除
    @Test
    public void delete() {
        String sql = "delete from book where id = ?";
        int update = jdbcTemplate.update(sql, 1);
        System.out.println(update);
    }

    // 批量删除
    @Test
    public void batchDelete() {
        String sql = "delete from book where id = ?";
        List<Object[]> list = new ArrayList<>();
        for (int i = 2; i < 7; i++) {
            Object[] objects = new Object[1];
            objects[0] = i;
            list.add(objects);
        }
        int[] update = jdbcTemplate.batchUpdate(sql, list);
        for (int i = 0; i < update.length; i++) {
            System.out.println(update[i]);
        }
    }

}