Spring-SpringMVC-MyBatis

2021-09-03

前言

SpringBoot稍微学了集成redis、dubbo等的demo，项目看不下去，还是沉下去看看底层原理比较充实，不然太虚了。

Java设计模式

反射

反射技术

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class ReflectServiceImpl{
    public void sayHello(String name){
        System.err.println("Hello " + name);
    }

    public static ReflectServiceImpl getInstance(){
        ReflectServiceImpl object = null;
        try{
            object = (ReflectServiceImpl) Class.forName("ReflectServiceImpl").newInstance();
        }catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex){
            ex.printStackTrace();
        }
        return object;
    }
}
class ReflectServiceImpl2{
    private String name;
    public ReflectServiceImpl2(String name){
        this.name = name;
    }
    public void sayHello(){
        System.err.println("Hello " + name);
    }

    public static ReflectServiceImpl2 getInstance(){
        ReflectServiceImpl2 object = null;
        try{
            object = (ReflectServiceImpl2) Class.forName("ReflectServiceImpl2")
                    .getConstructor(String.class)
                    .newInstance("张三");
        }catch (ClassNotFoundException | InstantiationException | IllegalAccessException
                | NoSuchMethodException | SecurityException | IllegalArgumentException
                | InvocationTargetException ex){
            ex.printStackTrace();
        }
        return object;
    }
}
public class ClassTest{
    public static Object reflectMethod(){
        Object obj = null;
        ReflectServiceImpl target = new ReflectServiceImpl();
        try{
            Method method = ReflectServiceImpl.class.getMethod("sayHello", String.class);
            obj = method.invoke(target, "张三");
        }catch (NoSuchMethodException | SecurityException | IllegalAccessException
                | IllegalArgumentException | InvocationTargetException ex){
            ex.printStackTrace();
        }
        return obj;
    }
    public static void main(String[] args){
        ReflectServiceImpl object = ReflectServiceImpl.getInstance();
        object.sayHello("World!");

        ReflectServiceImpl2 object1 = ReflectServiceImpl2.getInstance();
        object1.sayHello();

        reflectMethod();
    }
}

静态代理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface HelloWorld{
    void sayHelloWorld();
}
class HelloWorldImpl implements HelloWorld{
    @Override
    public void sayHelloWorld() {
        System.out.println("Hello World");
    }
}
class StaticProxyExample implements HelloWorld{
    private HelloWorldImpl helloWorldImpl;

    public StaticProxyExample(HelloWorldImpl helloWorldImpl){
        this.helloWorldImpl = helloWorldImpl;
    }

    public StaticProxyExample() throws ClassNotFoundException, IllegalAccessException, InstantiationException{
        this.helloWorldImpl = (HelloWorldImpl) this.getClass().getClassLoader().loadClass("HelloWorldImpl").newInstance();
    }

    @Override
    public void sayHelloWorld() {
        helloWorldImpl.sayHelloWorld();
    }

    public static void main(String[] args){
        // 第一种方式
        try{
            new HelloWorldImpl().sayHelloWorld();
        }catch (Exception e){
            e.printStackTrace();
        }
        // 第二种方式
        new StaticProxyExample(new HelloWorldImpl()).sayHelloWorld();
    }
}

动态代理

JDK动态代理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface HelloWorld{
    void sayHelloWorld();
}
class HelloWorldImpl implements HelloWorld{
    @Override
    public void sayHelloWorld() {
        System.out.println("Hello World");
    }
}
class StaticProxyExample implements HelloWorld{
    private HelloWorldImpl helloWorldImpl;

    public StaticProxyExample(HelloWorldImpl helloWorldImpl){
        this.helloWorldImpl = helloWorldImpl;
    }

    public StaticProxyExample() throws ClassNotFoundException, IllegalAccessException, InstantiationException{
        this.helloWorldImpl = (HelloWorldImpl) this.getClass().getClassLoader().loadClass("HelloWorldImpl").newInstance();
    }

    @Override
    public void sayHelloWorld() {
        helloWorldImpl.sayHelloWorld();
    }
}
class JdkProxyExample implements InvocationHandler{

    private Object target = null;

    public Object bind(Object target){
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("进入代理逻辑方法");
        System.out.println("在调度真实对象之前的服务");
        Object obj = method.invoke(target, args);
        System.out.println("在调用真实对象之后的服务");
        return obj;
    }
}
public class DynamicProxy {
    public static void main(String[] args){
        JdkProxyExample jdkProxyExample = new JdkProxyExample();
        HelloWorld proxy = (HelloWorld) jdkProxyExample.bind(new HelloWorldImpl());
        proxy.sayHelloWorld();
    }
}

进入代理逻辑方法
在调度真实对象之前的服务
Hello World
在调用真实对象之后的服务

Cglib动态代理

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

class ReflectServiceImpl{
    public void sayHello(String name){
        System.err.println("Hello " + name);
    }

    public static ReflectServiceImpl getInstance(){
        ReflectServiceImpl object = null;
        try{
            object = (ReflectServiceImpl) Class.forName("ReflectServiceImpl").newInstance();
        }catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex){
            ex.printStackTrace();
        }
        return object;
    }
}

class CglibProxyExample implements MethodInterceptor {

    public Object getProxy(Class cls){
        //CGlib enhancer增强类对象
        Enhancer enhancer = new Enhancer();
        //设置增强类型
        enhancer.setSuperclass(cls);
        //定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法
        enhancer.setCallback(this);
        //生成并返回代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.err.println("调用真实对象前");
        //CGlib反射调用真实对象方法
        Object result = methodProxy.invokeSuper(o, objects);
        System.err.println("调用真实对象后");
        return result;
    }
}
public class DynamicProxy {
    public static void main(String[] args){
        CglibProxyExample cpe = new CglibProxyExample();
        ReflectServiceImpl obj = (ReflectServiceImpl)cpe.getProxy(ReflectServiceImpl.class);
        obj.sayHello("张三");
    }
}

拦截器

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//拦截器接口
interface Interceptor{
    boolean before(Object proxy, Object target, Method method, Object[] args);
    void around(Object proxy, Object target, Method method, Object[] args);
    void after(Object proxy, Object target, Method method, Object[] args);
}

//拦截器
class MyInterceptor implements Interceptor{
    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.err.println("反射方法前逻辑");
        return false; //不反射被代理对象原有方法
    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.err.println("反射方法后逻辑");
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {
        System.err.println("取代了被代理对象的方法");
    }
}
class InterceptorJdkProxy implements InvocationHandler{
    private Object target; //真实对象
    private String interceptorClass = null; //拦截器全限定名

    public InterceptorJdkProxy(Object target, String interceptorClass){
        this.target = target;
        this.interceptorClass = interceptorClass;
    }

    public static Object bind(Object target, String interceptorClass){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InterceptorJdkProxy(target, interceptorClass));
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(interceptorClass == null) return method.invoke(target, args);

        Object result = null;

        //通过反射生成拦截器
        Interceptor interceptor = (Interceptor) Class.forName(interceptorClass).newInstance();

        //调用前置方法
        if(interceptor.before(proxy, target, method, args)){
            //反射原有对象方法
            result = method.invoke(target, args);
        }else interceptor.around(proxy, target, method, args);
        //调用后置方法
        interceptor.after(proxy, target, method, args);
        return result;
    }
}
public class InterceptorTest {

    public static void main(String[] args){
        HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(
                new HelloWorldImpl(),
                "MyInterceptor");
        proxy.sayHelloWorld();
    }
}

1
2
3

反射方法前逻辑
取代了被代理对象的方法
反射方法后逻辑

责任链模式/多级代理

责任链模式的经典方法见设计模式，这里用多级代理实现责任链模式

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//拦截器接口
interface Interceptor{
    boolean before(Object proxy, Object target, Method method, Object[] args);
    void around(Object proxy, Object target, Method method, Object[] args);
    void after(Object proxy, Object target, Method method, Object[] args);
}

//拦截器
class MyInterceptor implements Interceptor{
    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.err.println("反射方法前逻辑");
        return false; //不反射被代理对象原有方法
    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.err.println("反射方法后逻辑");
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {
        System.err.println("取代了被代理对象的方法");
    }
}

class Interceptor1 implements Interceptor{
    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器1】的before方法");
        return true;
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {}

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器1】的after方法");
    }
}

class Interceptor2 implements Interceptor{
    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器2】的before方法");
        return true;
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {

    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器2】的after方法");
    }
}

class Interceptor3 implements Interceptor{
    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器3】的before方法");
        return true;
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {

    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器3】的after方法");
    }
}

class InterceptorJdkProxy implements InvocationHandler{
    private Object target; //真实对象
    private String interceptorClass = null; //拦截器全限定名

    public InterceptorJdkProxy(Object target, String interceptorClass){
        this.target = target;
        this.interceptorClass = interceptorClass;
    }

    public static Object bind(Object target, String interceptorClass){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InterceptorJdkProxy(target, interceptorClass));
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(interceptorClass == null) return method.invoke(target, args);

        Object result = null;

        //通过反射生成拦截器
        Interceptor interceptor = (Interceptor) Class.forName(interceptorClass).newInstance();

        //调用前置方法
        if(interceptor.before(proxy, target, method, args)){
            //反射原有对象方法
            result = method.invoke(target, args);
        }else interceptor.around(proxy, target, method, args);
        //调用后置方法
        interceptor.after(proxy, target, method, args);
        return result;
    }
}
public class InterceptorTest {

    public static void main(String[] args){
        HelloWorld proxy1 = (HelloWorld) InterceptorJdkProxy.bind(
                new HelloWorldImpl(),
                "Interceptor1");
        HelloWorld proxy2 = (HelloWorld) InterceptorJdkProxy.bind(
                proxy1,
                "Interceptor2");
        HelloWorld proxy3 = (HelloWorld) InterceptorJdkProxy.bind(
                proxy2,
                "Interceptor3");
        proxy3.sayHelloWorld();
    }
}

【拦截器3】的before方法
【拦截器2】的before方法
【拦截器1】的before方法
Hello World
【拦截器1】的after方法
【拦截器2】的after方法
【拦截器3】的after方法

观察者模式

import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

class ProductList extends Observable{
    private List<String> productList = null; //产品列表
    private static ProductList instance; //类唯一实例, 单例模式
    private ProductList(){} //构造方法私有化

    public static ProductList getInstance(){
        if(instance == null){
            instance = new ProductList();
            instance.productList = new ArrayList<String>();
        }
        return instance;
    }

    public void addProductListObserver(Observer observer){
        this.addObserver(observer);
    }

    public void addProduct(String newProduct){
        productList.add(newProduct);
        System.out.println("产品列表新增了产品：" + newProduct);
        this.setChanged(); //设置被观察对象发生变化
        this.notifyObservers(newProduct); //通知观察者，并传递新产品
    }
}

class JingDongObserver implements Observer{
    @Override
    public void update(Observable o, Object product) {
        String newProduct = (String)product;
        System.err.println("发送新产品【" + newProduct + "】同步到京东商城");
    }
}

class TaoBaoObserver implements Observer{
    @Override
    public void update(Observable o, Object product) {
        String newProduct = (String)product;
        System.err.println("发送新产品【" + newProduct + "】同步到淘宝商城");
    }
}
public class ObserverTest {
    public static void main(String[] args){
        ProductList observable = ProductList.getInstance();
        TaoBaoObserver taoBaoObserver = new TaoBaoObserver();
        JingDongObserver jingDongObserver = new JingDongObserver();
        observable.addObserver(taoBaoObserver);
        observable.addObserver(jingDongObserver);
        observable.addProduct("新增产品1");
    }
}

1
2
3

产品列表新增了产品：新增产品1
发送新产品【新增产品1】同步到京东商城
发送新产品【新增产品1】同步到淘宝商城

建造者模式

简单实现以及建造者模式对比

import com.alibaba.fastjson.JSON;

class Item{
    //必填
    private String itemName;
    //必填
    private Integer type;
    //卡券必填
    private String code;
    //视频必填
    private String url;

    public Integer getType() {
        return type;
    }

    public String getCode() {
        return code;
    }

    public String getItemName() {
        return itemName;
    }

    public String getUrl() {
        return url;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public void setItemName(String itemName) {
        this.itemName = itemName;
    }

    public void setType(Integer type) {
        this.type = type;
    }

    public void setUrl(String url) {
        this.url = url;
    }
}

//建造者抽象类
abstract class ItemBuilder{
    protected Item item = new Item();

    public abstract void buildNormal();
    public abstract void builCard();
    public abstract void buildVideo();

    //返回产品对象
    public Item getResult(){
        return item;
    }
}

//建造者具体实现类
class ItemConcreteBuilder extends ItemBuilder{
    @Override
    public void buildNormal() {
        item.setItemName("普通商品");
        item.setType(1);
    }

    @Override
    public void builCard() {
        item.setItemName("卡券商品");
        item.setCode("123456");
        item.setType(2);
    }

    @Override
    public void buildVideo() {
        item.setItemName("视频商品");
        item.setType(3);
        item.setUrl("http://www.baidu.com");
    }
}

//具体建造者
class ItemDirector{
    private ItemBuilder itemBuilder;

    public ItemDirector(ItemBuilder itemBuilder){
        this.itemBuilder = itemBuilder;
    }

    public Item normalConstruct(){
        itemBuilder.buildNormal();
        return itemBuilder.getResult();
    }

    public Item cardConstruct(){
        itemBuilder.builCard();
        return itemBuilder.getResult();
    }

    public Item videoConstruct(){
        itemBuilder.buildVideo();
        return itemBuilder.getResult();
    }
}

public class BuilderTest {
    public static Item easyBuild(String op){
        Item item = new Item();
        if(op.equals("创建普通商品")){
            item.setItemName("xxx");
            item.setType(1);
        }
        if(op.equals("创建点子卡券商品")){
            item.setItemName("xxx");
            item.setCode("xxx");
            item.setType(2);
        }
        if(op.equals("创建视频")){
            item.setItemName("xxx");
            item.setUrl("https://www.baidu.com");
            item.setType(3);
        }
        return item;
    }

    public static void main(String[] args){
        ItemBuilder builder = new ItemConcreteBuilder();
        ItemDirector director = new ItemDirector(builder);
        Item item = director.normalConstruct();
        System.out.println(JSON.toJSONString(item));

        Item item1 = director.cardConstruct();
        System.out.println(JSON.toJSON(item1));

        Item item2 = director.videoConstruct();
        System.out.println(JSON.toJSONString(item2));
    }
}

1
2
3

{"itemName":"普通商品","type":1}
{"itemName":"卡券商品","code":"123456","type":2}
{"code":"123456","itemName":"视频商品","type":3,"url":"http://www.baidu.com"}

静态内部类的实现

class CopyItem{
    private String name;
    private Long stock;

    public String getName(){
        return name;
    }

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

    public void setStock(Long stock) {
        this.stock = stock;
    }

    public Long getStock() {
        return stock;
    }

    private CopyItem(ItemBuilder builder){
        this.name = builder.name;
        this.stock = builder.stock;
    }

    public static class ItemBuilder{
        private static final Long DEFAULT_STOCK = 0L;
        private String name;
        private Long stock = DEFAULT_STOCK;

        public CopyItem build(){
            return new CopyItem(this);
        }

        public ItemBuilder setName(String name){
            if(StringUtils.isBlank(name)){
                throw new IllegalArgumentException("....");
            }
            this.name = name;
            return this;
        }

        public ItemBuilder setStock(Long stock){
            if(stock > 9999999999L){
                throw new IllegalArgumentException("库存数量错误");
            }
            this.stock = stock;
            return this;
        }
    }

    public static void main(String[] args){

        CopyItem copyItem = new CopyItem.ItemBuilder().setName("copyItem").build();
        System.out.println(JSON.toJSONString(copyItem));

        CopyItem copyItem1 = new CopyItem.ItemBuilder().setStock(99999999999L).build();
        System.out.println(JSON.toJSONString(copyItem1));
    }
}

Exception in thread "main" java.lang.IllegalArgumentException: 库存数量错误
	at CopyItem$ItemBuilder.setStock(BuilderTest.java:152)
	at BuilderTest.main(BuilderTest.java:194)
{"name":"copyItem","stock":0}

互联网持久层框架——MyBatis

认识MyBatis核心组件

Mybatis的核心组件

SqlSessionFactoryBuilder（构造—）：它会根据配置或者代码来生成SqlSessionFactory,采用的是分步构建的Builder模式；
SqlSessionFactory （工厂接口）：依靠它来生成SqlSession，使用的是工厂模式；
SqlSession（会话）：一个既可以发送SQL执行返回结果，也可以获取Mapper的接口。在现有的技术中，一般我们会让其在业务逻辑代码中“消失”，而使用的是MyBatis提供的SQL Mapper接口编程技术，它能提高代码的可读性和可维护性；
SQL Mapper（映射器）：MyBatis新设计存在的组件，它由一个Java接口和XML文件（或注解）构成，需要给出对应的SQL和映射规则。它负责发送SQL去执行，并返回结果。

在线文档
 Github

SqlSessionFactory

XML构建方式（推荐）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org/DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 别名 -->
    <typeAliases>
        <typeAlias alias="role" type="Role"/>
    </typeAliases>
    <!-- 数据库环境 -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 映射文件 -->
    <mappers>
        <mapper resource="RoleMapper.xml" />
    </mappers>
</configuration>

SqlSessionFactory sqlSessionFactory = null;
        String resource = "mybatis-config.xml";
        InputStream inputStream;
        try{
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        }catch (IOException e){
            e.printStackTrace();
        }

代码构建方式

package mybatis;

import org.apache.ibatis.datasource.pooled.PooledDataSource;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.transaction.TransactionFactory;
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;

class Role{

}
interface RoleMapper{

}

public class Connector {
    public static SqlSessionFactory connectDatabase(){
        //数据库连接池信息
        PooledDataSource dataSource = new PooledDataSource();
        dataSource.setDriver("com.mysql.jdbc.Driver");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        dataSource.setUrl("jdbc:mysql://localhost:3306/ssm");
        dataSource.setDefaultAutoCommit(false);

        //采用MyBatis的JDBC事务方式
        TransactionFactory transactionFactory = new JdbcTransactionFactory();
        Environment environment = new Environment("development", transactionFactory, dataSource);

        //创建Configuration对象
        Configuration configuration = new Configuration(environment);

        //注册一个MyBatis上下文别名
        configuration.getTypeAliasRegistry().registerAlias("role", Role.class);

        //加入一个映射器
        configuration.addMapper(RoleMapper.class);

        //使用SqlSessionFactoryBuilder构建SqlSessionFractory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
        return sqlSessionFactory;
    }
    public static void main(String[] args){

    }
}

SqlSession

public static void helper(){
  //定义SqlSession
  SqlSession sqlSession = null;
  try{
      //打开SqlSession会话
      SqlSessionFactory sqlSessionFactory = connectDatabase();
      sqlSession = sqlSessionFactory.openSession();
  }catch (Exception e){
      sqlSession.rollback();
  }finally {
      //在finally语句汇总确保资源被顺利关闭
      if(sqlSession != null) sqlSession.close();
  }
}

Mapper映射器

POJO和映射接口

class Role{
    private Long id;
    private String roleName;
    private String note;
}
interface RoleMapper{
    Role getRole(Long id);
}

XML映射文件实现

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<mapper namespace="RoleMapper">
    <select id="getRole" parameterType="long" resultType="role">
        select id, role_name as roleName, note from t_role where id = #{id}
    </select>
</mapper>

注解实现

interface RoleMapper{
  @Select("select id, role_name as roleName, note from t_role where id = #{id}")
  public Role getRole(Long id);
}

SqlSession发送SQL

1	Role role = (Role) sqlSession.selectOne("RoleMapper.getRole", 1L);

用Mapper接口发送SQL（推荐）

1 2	RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class); Role role = roleMapper.getRole(1L);

生命周期

SqlSessionFatoryBuilder的作用在于创建SqlSessionFactory，创建成功后，SqlSessionFactoryBuilder就失去了作用，所以它只能存在于创建SqlSessionFactory的方法中，而不要让其长期存在；
SqlSessionFactory可以被认为是一个数据库连接池，它的作用是创建SqlSession接口对象。所以SqlSessionFactory的生命周期存在于整个MyBatis的应用之中，所以一旦创建了SqlSessionFactory，就要长期保存它，直至不再使用Mybatis。
SqlSession相当于一个数据库连接，可以字啊一个事务里面执行多条SQL，然后commit、rollback等，其应该存活在一个业务请求中，处理完整个请求后，应当关闭连接，归还给SqlSessionFactory，否则数据库资源就很快被耗费光，系统就会瘫痪，所以需要try/catch/finally语句来保证其正确关闭
Mapper是一个借口，由SqlSession创建，所以其最大生命周期至多和SqlSession保持一致，尽管它很好用，但是由于SqlSession的关闭，它的数据库连接资源也会消失，所以它的生命周期应该小于等于SqlSession的生命周期。

实例

log4j.properties

log4j.rootLogger=DEBUG,stdout
log4j.logger.org.mybatis=DEBUG
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p %d %c: %m%n

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org/DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- 别名 -->
    <typeAliases>
        <typeAlias alias="role" type="mybatis.Role"/>
    </typeAliases>
    <!-- 数据库环境 -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--  映射文件  -->
    <mappers>
        <mapper resource="mybatis\RoleMapper.xml"/>
    </mappers>
</configuration>

RoleMapper.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="mybatis.RoleMapper">
    <insert id="insertRole" parameterType="role">
        insert into t_role(role_name, note) values(#{roleName}, #{note})
    </insert>

    <delete id="deleteRole" parameterType="long">
        delete from t_role where id = #{id}
    </delete>

    <update id="updateRole" parameterType="role">
        update t_role set role_name = #{roleName}, note = #{note} where id = #{id}
    </update>

    <select id="getRole" parameterType="long" resultType="role">
        select id, role_name as roleName, note from t_role where id = #{id}
    </select>

    <select id="findRoles" parameterType="string" resultType="role">
        select id, role_name as roleName, note from t_role
        where role_name like concat('%', ${roleName}, '%')
    </select>
</mapper>

Role

package mybatis;

public class Role {

    private Long id;
    private String roleName;
    private String note;

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

    public void setNote(String note) {
        this.note = note;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public Long getId() {
        return id;
    }

    public String getNote() {
        return note;
    }

    public String getRoleName() {
        return roleName;
    }
}

RoleMapper

package mybatis;

import java.util.List;

public interface RoleMapper {
    int insertRole(Role role);
    int deleteRole(Long id);
    int updateRole(Role role);
    Role getRole(Long id);
    List<Role> findRoles(String roleName);
}

SqlSessionFactoryUtil

package mybatis;

import com.alibaba.fastjson.JSON;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class SqlSessionFactoryUtils {
    private final static Class<SqlSessionFactoryUtils> LOCK = SqlSessionFactoryUtils.class;

    private static SqlSessionFactory sqlSessionFactory = null;

    private SqlSessionFactoryUtils(){} //单例模式

    public static SqlSessionFactory getSqlSessionFactory(){
        synchronized (LOCK){
            if(sqlSessionFactory != null) return sqlSessionFactory;
            String resource = "mybatis\\mybatis-config.xml";
            InputStream inputStream;
            try{
                inputStream = Resources.getResourceAsStream(resource);
                sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            }catch (IOException e){
                e.printStackTrace();
                return null;
            }
            return sqlSessionFactory;
        }
    }

    public static SqlSession openSqlSession(){
        if(sqlSessionFactory == null) getSqlSessionFactory();
        return sqlSessionFactory.openSession();
    }
    public static void main(String[] args){
        //log4j.properties默认是在src目录下，如果不是需要重新设置
        //加载log4j的配置文件
//        FileInputStream fileInputStream = null;
//        try{
//            Properties properties = new Properties();
//            fileInputStream = new FileInputStream("src\\mybatis\\log4j.properties");
//            properties.load(fileInputStream);
//            PropertyConfigurator.configure(properties);
//        }catch (Exception e){
//            e.printStackTrace();
//        }finally {
//            if(fileInputStream != null){
//                try{
//                    fileInputStream.close();
//                }catch (IOException e){
//                    e.printStackTrace();
//                }
//            }
//        }
        Logger logger = Logger.getLogger(SqlSessionFactoryUtils.class);
        SqlSession sqlSession = null;
        try{
            sqlSession = SqlSessionFactoryUtils.openSqlSession();
            RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
            Role role = roleMapper.getRole(1L);
            //System.out.println(JSON.toJSONString(role));
            logger.info(role.getRoleName());
        }finally {
            if(sqlSession != null) sqlSession.close();
        }
    }
}

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=59486:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-03 20:22:01,812 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-03 20:22:01,826 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-03 20:22:01,826 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-03 20:22:01,826 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-03 20:22:01,826 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-03 20:22:01,898 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-03 20:22:02,242 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 194481424.
DEBUG 2021-09-03 20:22:02,242 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b978d10]
DEBUG 2021-09-03 20:22:02,245 mybatis.RoleMapper.getRole: ==>  Preparing: select id, role_name as roleName, note from t_role where id = ?
DEBUG 2021-09-03 20:22:02,274 mybatis.RoleMapper.getRole: ==> Parameters: 1(Long)
DEBUG 2021-09-03 20:22:02,301 mybatis.RoleMapper.getRole: <==      Total: 1
 INFO 2021-09-03 20:22:02,302 mybatis.SqlSessionFactoryUtils: John
DEBUG 2021-09-03 20:22:02,302 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b978d10]
DEBUG 2021-09-03 20:22:02,302 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b978d10]
DEBUG 2021-09-03 20:22:02,302 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 194481424 to pool.

Process finished with exit code 0

MyBatis配置

MyBatis配置文件并不复杂，其所有元素如下所示：
MyBatis配置项的顺序不能颠倒。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org/DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration> <!--配置-->
  <properties/> <!--属性-->
  <settings/> <!--设置-->
  <typeAliases/> <!--类型命名-->
  <typeHandlers/> <!--类型处理器-->
  <objectFactory/> <!--对象工厂-->
  <plugins/> <!--插件-->
  <environments> <!--配置环境-->
    <environment> <!--环境变量-->
      <transactionManager/> <!--事务管理器-->
      <dataSource/> <!--数据源-->
    </environment>
  <environments>
  <databaseIdProvider/> <!--数据库厂商标识-->
  <mappers/> <!--映射器-->
</configuration>

properties属性

properties属性可以给系统配置一些运行参数，可以放在XML文件或者properties文件中，而不是放在Java编码汇总，方便参数修改。
三种方式配置：

property子元素
properties文件
程序代码传递

property子元素

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org/DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties>
        <property name="database.driver" value="com.mysql.cj.jdbc.Driver"/>
        <property name="database.url" value="jdbc:mysql://localhost:3306/ssm"/>
        <property name="database.username" value="root"/>
        <property name="database.password" value="123456"/>
    </properties>
    <!-- 别名 -->
    <typeAliases>
        <typeAlias alias="role" type="MyBatis.Role"/>
    </typeAliases>
    <!-- 数据库环境 -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${database.driver}"/>
                <property name="url" value="${database.url}"/>
                <property name="username" value="${database.username}"/>
                <property name="password" value="${database.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 映射文件 -->
    <mappers>
        <mapper resource="MyBatis.RoleMapper.xml" />
    </mappers>
</configuration>

使用properties文件

database.driver=com.mysql.cj.jdbc.Driver
database.url=jdbc:mysql://localhost:3306/ssm
database.username=root
database.password=123456

在xml配置通过属性resource来引入properties文件

1	<properties resource="jdbc.properties">

使用程序传递方式传递参数

String resource = "mybatis-config.xml";
InputStream inputStream;
InputStream in = Resources.getResourceAsStream("jdbc.properties");
Properties props = new Properties();
props.load(in);
String username = props.getProperty("database.username");
String password = props.getProperty("database.password");
//解密用户和密码，并在属性中重置
props.put("database.username", CodeUtils.decode(username));
props.put("database.password", CodeUtils.decode(password));
inputStream = Resources.getResourceAsStream(resource);
//使用程序传递的方式覆盖原有的properties属性参数
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, props);

优先级

最优先的是程序传递的方式，其次是使用properties文件的方式，最后是使用property子元素的方式，MyBatis会根据优先级来覆盖原先配置的属性值。

settings设置

settings是MyBatis中最复杂的配置，它能深刻影响MyBatis底层的运行，但是在大部分情况下使用默认值便可以运行，所以在大部分情况下不需要大量配置它，只需要修改一些常用的规则即可，比如自动映射、驼峰命名映射、级联规则、是否启动缓存、执行器（Executor）类型等。

配置项	作用	配置选项说明	默认值
cacheEnable	改配置影响所有映射器中配置缓存的全局开关	true\|false	true
lazyLoadingEnable	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。在特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态	true\|false	false
aggressiveLazyLoading	当启用时，对任意延迟属性的调用会使带有延迟加载属性的对象完整加载；反之，每种属性将会按需加载	true\|false	版本3.4.1（不包含）之前true，之后false
multipleResultSetsEnabled	是否允许单一语句返回多结果集（需要兼容驱动）	true\|false	true
useColumnLabel	使用列标签代替列名。不同的驱动会有不同的表现，具体可参考相关驱动文档或通过测试这两种不同的模式来观察所用驱动的结果	true\false	true
useGeneratedKeys	允许JDBC支持自动生成主键，需要驱动兼容。如果设置为true，则这个设置强制使用自动生成主键，尽管一些驱动不能兼容但仍可正常工作（比如Derby）	true\false	false
autoMappingBehavior	指定MyBatis应如何自动映射列到字段或属性。NONE表示取消自动映射：PARTIAL表示自动映射，没有定义嵌套结果集合映射结果集。FULL会自动映射任意复杂的结果集（无论是否嵌套）	NONE、PARTIAL、FULL	PARTIAL
autoMappingUnknownColumnBehavior	指定自动映射当中未知列（或未知属性类型）时的行为，默认是不处理，只有当日志级别达到WARN级别或者以下，才会显示相关日志，如果处理失败会抛出SqlSessionException异常	NONE、PARTIAL、FULL	NONE
defaultExecutorType	配置默认的执行器。SIMPLE是普通的执行器；REUSE会重用预处理语句（prepared statements）；BATCH执行器将重用语句并执行批量更新	SIMPLE、REUSE、BATCH	SIMPLE
defaultStatementTimeout	设置超时时间，它决定驱动等待数据库响应的秒数	任何正整数	Not Set(null)
defaultFetchSize	设置数据库驱动程序默认返回的条数限制，此参数可以重新设置	任何正整数	Not Set(null)
safeRowBoundsEnabled	允许在嵌套语句中使用分页（RowBounds）。如果允许，设置false	true\|false	false
safeResultHandlerEnabled	允许在嵌套语句中使用分页（ResultHandler）。如果允许，设置false	true\|false	true
mapUnderscoreTocAmelCase	是否开启自动驼峰命名规则映射，即从经典数据库列名A_COLUMN到经典Java属性名aColumn的类似映射	true\|false	false
localCacheScope	MyBatis利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。默认值为SESSION。这种情况下会缓存一个会话中执行的所有查询。若设置值为STATEMENT，本地会话仅用在语句执行上，对相同SqlSession的不同调用将不会共享数据	SESSION\|STATEMENT	SESSION
jdbcTypeForNull	当没有为参数提供特定的JDBC类型时，为空值指定JDBC类型。某些驱动需要指定列的JDBC类型，多数情况直接用一般类型即可，比如NULL，VARCHAR或OTHER	NULL、VARCHAR、OTHER	OTHER
lazyLoadTriggerMethods	指定哪个对象的方法除法一次延迟加载	——	equals、clone、hashCode、toString
defaultScriptingLanuage	指定动态SQL生成的默认语言	——	org.apache.ibatis.scripting. xmltags.XMLDynamicLanguageDriver
callSettersOnNulls	指定当结果集中值为null时，是否调用映射对象的setter（map对象时为put）方法，这对于Map.keysSet()依赖或null值初始化时是有用的。注意，基本类型（int、boolean等）不能设置成null	true\|false	false
logPrefix	指定MyBatis增加到日志名称的前缀	任何字符串	Not set
logImpl	指定MyBatis所用日志的具体实现，未指定时将自动查找	SLF4J\|LOG4J\|LOG4J2\| JDK_LOGGING\|COMMONS_LOGGING\| STDOUT_LOGGING\|NO_LOGGING	Not set
proxyFactory	指定MyBatis创建具有延迟加载能力的对象所用到的代理工具	CGLIB\|JAVASSIST	JAVASSIST （MyBatis版本为3.3及以上的）
vfsImpl	指定VFS的实现类	提供VFS类的全限定名，如果存在多个，可以使用逗号分隔	Not set
useActualParamName	允许用方法参数中声明的实际名称引用参数。要使用此功能，项目必须被编译为Java8参数的选择。（从版本3.4.1开始可以使用）	true\|false	true

<settings>
      <setting name="cacheEnabled" value="true"/>
      <setting name="lazyLoadingEnabled" value="true"/>
      <setting name="multipleResultSetsEnabled" value="true"/>
      <setting name="useColumnLabel" value="true"/>
      <setting name="useGeneratedKeys" value="false"/>
      <setting name="autoMappingBehavior" value="PARTIAL"/>
      <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
      <setting name="defaultExecutorType" value="SIMPLE"/>
      <setting name="defaultStatementTimeout" value="25"/>
      <setting name="defaultFetchSize" value="100"/>
      <setting name="safeRowBoundsEnabled" value="false"/>
      <setting name="mapUnderscoreToCamelCase" value="false"/>
      <setting name="localCacheScope" value="SESSION"/>
      <setting name="jdbcTypeForNull" value="OTHER"/>
      <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
  </settings>

typeAliases别名

由于类的全限定名称很长，需要大量使用的时候，总写那么长的名称不方便。

系统定义别名

在MyBatis的初始化过程中，系统自动初始化了一些别名。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.type;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import org.apache.ibatis.io.ResolverUtil;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.io.ResolverUtil.IsA;

public class TypeAliasRegistry {
    private final Map<String, Class<?>> typeAliases = new HashMap();

    public TypeAliasRegistry() {
        this.registerAlias("string", String.class);
        this.registerAlias("byte", Byte.class);
        this.registerAlias("long", Long.class);
        this.registerAlias("short", Short.class);
        this.registerAlias("int", Integer.class);
        this.registerAlias("integer", Integer.class);
        this.registerAlias("double", Double.class);
        this.registerAlias("float", Float.class);
        this.registerAlias("boolean", Boolean.class);
        this.registerAlias("byte[]", Byte[].class);
        this.registerAlias("long[]", Long[].class);
        this.registerAlias("short[]", Short[].class);
        this.registerAlias("int[]", Integer[].class);
        this.registerAlias("integer[]", Integer[].class);
        this.registerAlias("double[]", Double[].class);
        this.registerAlias("float[]", Float[].class);
        this.registerAlias("boolean[]", Boolean[].class);
        this.registerAlias("_byte", Byte.TYPE);
        this.registerAlias("_long", Long.TYPE);
        this.registerAlias("_short", Short.TYPE);
        this.registerAlias("_int", Integer.TYPE);
        this.registerAlias("_integer", Integer.TYPE);
        this.registerAlias("_double", Double.TYPE);
        this.registerAlias("_float", Float.TYPE);
        this.registerAlias("_boolean", Boolean.TYPE);
        this.registerAlias("_byte[]", byte[].class);
        this.registerAlias("_long[]", long[].class);
        this.registerAlias("_short[]", short[].class);
        this.registerAlias("_int[]", int[].class);
        this.registerAlias("_integer[]", int[].class);
        this.registerAlias("_double[]", double[].class);
        this.registerAlias("_float[]", float[].class);
        this.registerAlias("_boolean[]", boolean[].class);
        this.registerAlias("date", Date.class);
        this.registerAlias("decimal", BigDecimal.class);
        this.registerAlias("bigdecimal", BigDecimal.class);
        this.registerAlias("biginteger", BigInteger.class);
        this.registerAlias("object", Object.class);
        this.registerAlias("date[]", Date[].class);
        this.registerAlias("decimal[]", BigDecimal[].class);
        this.registerAlias("bigdecimal[]", BigDecimal[].class);
        this.registerAlias("biginteger[]", BigInteger[].class);
        this.registerAlias("object[]", Object[].class);
        this.registerAlias("map", Map.class);
        this.registerAlias("hashmap", HashMap.class);
        this.registerAlias("list", List.class);
        this.registerAlias("arraylist", ArrayList.class);
        this.registerAlias("collection", Collection.class);
        this.registerAlias("iterator", Iterator.class);
        this.registerAlias("ResultSet", ResultSet.class);
    }

    public <T> Class<T> resolveAlias(String string) {
        try {
            if (string == null) {
                return null;
            } else {
                String key = string.toLowerCase(Locale.ENGLISH);
                Class value;
                if (this.typeAliases.containsKey(key)) {
                    value = (Class)this.typeAliases.get(key);
                } else {
                    value = Resources.classForName(string);
                }

                return value;
            }
        } catch (ClassNotFoundException var4) {
            throw new TypeException("Could not resolve type alias '" + string + "'.  Cause: " + var4, var4);
        }
    }

    public void registerAliases(String packageName) {
        this.registerAliases(packageName, Object.class);
    }

    public void registerAliases(String packageName, Class<?> superType) {
        ResolverUtil<Class<?>> resolverUtil = new ResolverUtil();
        resolverUtil.find(new IsA(superType), packageName);
        Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
        Iterator var5 = typeSet.iterator();

        while(var5.hasNext()) {
            Class<?> type = (Class)var5.next();
            if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
                this.registerAlias(type);
            }
        }

    }

    public void registerAlias(Class<?> type) {
        String alias = type.getSimpleName();
        Alias aliasAnnotation = (Alias)type.getAnnotation(Alias.class);
        if (aliasAnnotation != null) {
            alias = aliasAnnotation.value();
        }

        this.registerAlias(alias, type);
    }

    public void registerAlias(String alias, Class<?> value) {
        if (alias == null) {
            throw new TypeException("The parameter alias cannot be null");
        } else {
            String key = alias.toLowerCase(Locale.ENGLISH);
            if (this.typeAliases.containsKey(key) && this.typeAliases.get(key) != null && !((Class)this.typeAliases.get(key)).equals(value)) {
                throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + ((Class)this.typeAliases.get(key)).getName() + "'.");
            } else {
                this.typeAliases.put(key, value);
            }
        }
    }

    public void registerAlias(String alias, String value) {
        try {
            this.registerAlias(alias, Resources.classForName(value));
        } catch (ClassNotFoundException var4) {
            throw new TypeException("Error registering type alias " + alias + " for " + value + ". Cause: " + var4, var4);
        }
    }

    public Map<String, Class<?>> getTypeAliases() {
        return Collections.unmodifiableMap(this.typeAliases);
    }
}

Configuration配置的别名。

//事务方式别名
typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
//数据源类型别名
typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);
//缓存策略别名
typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
typeAliasRegistry.registerAlias("LRU", LruCache.class);
typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
typeAliasRegistry.registerAlias("WEAK", WeakCache.class);
//数据库标识别名
typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseProvider.class);
//语言驱动类别名
typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);
//日志类别名
typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
...

自定义别名

<typeAliases>
  <typeAlias alias="role" type="com.louris.mybatis.Role"/>
  <package name="com.louris.mybatis.pojo"/>
</typeAliases>

如果有很多类需要定义别名，那么可以用以下方式进行配置，比如”com.louris.mybatis.pojo”包中的类，将其中第一个字母变为小写作为其别名，比如类Role的别名会编程role，User的别名为user。

1
2
3

<typeAliases>
  <package name="com.louris.mybatis.pojo"/>
</typeAliases>

上述这种可能出现重名，需要注解@Alias()进行区分。


@Alias("user3")
public Class User{
  ....
}

typeHandler类型转换器

在JDBC中，需要在PreparedStatement对象中设置那些已经预编译过的SQL语句的参数。执行SQL后，会通过ResultSet对象获取得到数据库的数据，而这些MyBatis是根据数据的类型通过typeHandler来实现的。在typeHandler中，分为jdbcType和javaType，其中jdbcType用于定义数据库类型，而javaType用于定义Java类型，那么typeHandler的作用就是承担jdbcType和javaType之间的相互转换。多数情况下爱不需要我们配置typeHandler、jdbcType、javaType，因为MyBatis会探测应该使用什么类型的typeHandler进行处理，但是有些场景无法探测到。对于那些需要使用自定义枚举的场景，或者数据库使用特殊数据类型的场景，可以使用自定义的typeHandler去处理类型之间的转换问题。

系统定义的typeHandler

BooleanTypeHandler
ByteTypeHandler
IntegerTypeHanlder

…

这些都是MyBatis系统已经创建好的typeHandler，大部的情况下无须显式地声明jdbcType和javaType，或者用typeHandler去指定typeHandler来实现数据类型转换，因为MyBatis系统会自己探测。

在MyBatis中typeHandler都要实现接口org.apache.ibatis.type.TypeHandler：

public interface TypeHandler<T>{
  void setParameter(PreparedStatement ps, int i, T parameter, jdbcType jdbcType) throws SQLException;
  T getResult(ResultSet rs, String columnName) throws SQLException;
  T getResult(ResultSet rs, int columnIndex) throws SQLException;
  T getResult(CallableStatement cs, int columnIndex) throw SQLException;
}

而各类typeHandler都是集成org.apache.ibatis.BaseTypeHandler

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.type;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.ibatis.executor.result.ResultMapException;
import org.apache.ibatis.session.Configuration;

public abstract class BaseTypeHandler<T> extends TypeReference<T> implements TypeHandler<T> {
    /** @deprecated */
    @Deprecated
    protected Configuration configuration;

    public BaseTypeHandler() {
    }

    /** @deprecated */
    @Deprecated
    public void setConfiguration(Configuration c) {
        this.configuration = c;
    }

    public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
        if (parameter == null) {
            if (jdbcType == null) {
                throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");
            }

            try {
                ps.setNull(i, jdbcType.TYPE_CODE);
            } catch (SQLException var7) {
                throw new TypeException("Error setting null for parameter #" + i + " with JdbcType " + jdbcType + " . Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. Cause: " + var7, var7);
            }
        } else {
            try {
                this.setNonNullParameter(ps, i, parameter, jdbcType);
            } catch (Exception var6) {
                throw new TypeException("Error setting non null for parameter #" + i + " with JdbcType " + jdbcType + " . Try setting a different JdbcType for this parameter or a different configuration property. Cause: " + var6, var6);
            }
        }

    }

    public T getResult(ResultSet rs, String columnName) throws SQLException {
        try {
            return this.getNullableResult(rs, columnName);
        } catch (Exception var4) {
            throw new ResultMapException("Error attempting to get column '" + columnName + "' from result set.  Cause: " + var4, var4);
        }
    }

    public T getResult(ResultSet rs, int columnIndex) throws SQLException {
        try {
            return this.getNullableResult(rs, columnIndex);
        } catch (Exception var4) {
            throw new ResultMapException("Error attempting to get column #" + columnIndex + " from result set.  Cause: " + var4, var4);
        }
    }

    public T getResult(CallableStatement cs, int columnIndex) throws SQLException {
        try {
            return this.getNullableResult(cs, columnIndex);
        } catch (Exception var4) {
            throw new ResultMapException("Error attempting to get column #" + columnIndex + " from callable statement.  Cause: " + var4, var4);
        }
    }

    public abstract void setNonNullParameter(PreparedStatement var1, int var2, T var3, JdbcType var4) throws SQLException;

    public abstract T getNullableResult(ResultSet var1, String var2) throws SQLException;

    public abstract T getNullableResult(ResultSet var1, int var2) throws SQLException;

    public abstract T getNullableResult(CallableStatement var1, int var2) throws SQLException;
}

通过BaseTypeHandler，MyBatis把javaType和jdbcType相互转换，并通过org.apache.ibatis.type.TypeHandlerRegistry类对象的register方法进行注册。

public TypeHandlerRegistry(Configuration configuration) {
    this.jdbcTypeHandlerMap = new EnumMap(JdbcType.class);
    this.typeHandlerMap = new ConcurrentHashMap();
    this.allTypeHandlersMap = new HashMap();
    this.defaultEnumTypeHandler = EnumTypeHandler.class;
    this.unknownTypeHandler = new UnknownTypeHandler(configuration);
    this.register((Class)Boolean.class, (TypeHandler)(new BooleanTypeHandler()));
    this.register((Class)Boolean.TYPE, (TypeHandler)(new BooleanTypeHandler()));
    this.register((JdbcType)JdbcType.BOOLEAN, (TypeHandler)(new BooleanTypeHandler()));
    this.register((JdbcType)JdbcType.BIT, (TypeHandler)(new BooleanTypeHandler()));
    this.register((Class)Byte.class, (TypeHandler)(new ByteTypeHandler()));
    this.register((Class)Byte.TYPE, (TypeHandler)(new ByteTypeHandler()));
    this.register((JdbcType)JdbcType.TINYINT, (TypeHandler)(new ByteTypeHandler()));
}

自定义typeHandler

MyTypeHandler

package mybatis;

import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeHandler;
import org.apache.log4j.Logger;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;


public class MyTypeHandler implements TypeHandler<String> {

    private final Logger logger = Logger.getLogger(MyTypeHandler.class);

    @Override
    public void setParameter(PreparedStatement preparedStatement, int i, String parameter, JdbcType jdbcType) throws SQLException {
        logger.info("设置string参数【" + parameter + "】");
        preparedStatement.setString(i, parameter);
    }

    @Override
    public String getResult(ResultSet resultSet, String columnName) throws SQLException {
        String result = resultSet.getString(columnName);
        logger.info("读取string参数1【" + result + "】");
        return result;
    }

    @Override
    public String getResult(ResultSet resultSet, int i) throws SQLException {
        String result = resultSet.getString(i);
        logger.info("读取string参数2【" + result + "】");
        return result;
    }

    @Override
    public String getResult(CallableStatement callableStatement, int i) throws SQLException {
        String result = callableStatement.getString(i);
        logger.info("读取string参数3【" + result + "】");
        return result;
    }
}

RoleMapper.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="mybatis.RoleMapper">
    <resultMap id="roleMapper" type="role">
        <result property="id" column="id"/>
        <result property="roleName" column="role_name" jdbcType="VARCHAR" javaType="string"/>
        <result property="note" column="note" typeHandler="mybatis.MyTypeHandler"/>
    </resultMap>

    <insert id="insertRole" parameterType="role">
        insert into t_role(role_name, note) values(#{roleName}, #{note})
    </insert>

    <delete id="deleteRole" parameterType="long">
        delete from t_role where id = #{id}
    </delete>

    <update id="updateRole" parameterType="role">
        update t_role set role_name = #{roleName}, note = #{note} where id = #{id}
    </update>

    <select id="getRole" parameterType="long" resultType="role">
        select id, role_name as roleName, note from t_role where id = #{id}
    </select>

    <select id="findRoles" parameterType="string" resultType="role">
        select id, role_name as roleName, note from t_role
        where role_name like concat('%', #{roleName, jdbcType=VARCHAR, javaType=string}, '%')
    </select>

    <select id="findRoles2" parameterType="string" resultMap="roleMapper">
        select id, role_name, note from t_role
        where note like concat('%', #{note, typeHandler=mybatis.MyTypeHandler}, '%')
    </select>
</mapper>

RoleMapper

package mybatis;

import java.util.List;

public interface RoleMapper {
    int insertRole(Role role);
    int deleteRole(Long id);
    int updateRole(Role role);
    Role getRole(Long id);
    List<Role> findRoles(String roleName);
    List<Role> findRoles2(String note);
}

SqlSessionFactoryUtils

package mybatis;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.log4j.Logger;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class SqlSessionFactoryUtils {
    private final static Class<SqlSessionFactoryUtils> LOCK = SqlSessionFactoryUtils.class;

    private static SqlSessionFactory sqlSessionFactory = null;

    private SqlSessionFactoryUtils(){} //单例模式

    public static SqlSessionFactory getSqlSessionFactory(){
        synchronized (LOCK){
            if(sqlSessionFactory != null) return sqlSessionFactory;
            String resource = "mybatis\\mybatis-config.xml";
            InputStream inputStream;
            try{
                inputStream = Resources.getResourceAsStream(resource);
                sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            }catch (IOException e){
                e.printStackTrace();
                return null;
            }
            return sqlSessionFactory;
        }
    }

    public static SqlSession openSqlSession(){
        if(sqlSessionFactory == null) getSqlSessionFactory();
        return sqlSessionFactory.openSession();
    }
    public static void main(String[] args){
        //log4j.properties默认是在src目录下，如果不是需要重新设置
        //加载log4j的配置文件
//        FileInputStream fileInputStream = null;
//        try{
//            Properties properties = new Properties();
//            fileInputStream = new FileInputStream("src\\mybatis\\log4j.properties");
//            properties.load(fileInputStream);
//            PropertyConfigurator.configure(properties);
//        }catch (Exception e){
//            e.printStackTrace();
//        }finally {
//            if(fileInputStream != null){
//                try{
//                    fileInputStream.close();
//                }catch (IOException e){
//                    e.printStackTrace();
//                }
//            }
//        }
        Logger logger = Logger.getLogger(SqlSessionFactoryUtils.class);
        SqlSession sqlSession = null;
        try{
            sqlSession = SqlSessionFactoryUtils.openSqlSession();
            RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
            Role role = roleMapper.getRole(1L);
            //System.out.println(JSON.toJSONString(role));
            logger.info(role.getRoleName());
            List<Role> list= roleMapper.findRoles(pageParams,"John");
            logger.info(list.get(0).getNote());

            List<Role> list1 = roleMapper.findRoles2("Hello World!");
            logger.info(list1.get(0).getRoleName());
        }finally {
            if(sqlSession != null) sqlSession.close();
        }
    }
}

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=60353:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-05 11:31:27,625 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-05 11:31:27,639 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 11:31:27,639 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 11:31:27,639 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 11:31:27,639 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 11:31:27,718 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-05 11:31:28,062 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 1940445711.
DEBUG 2021-09-05 11:31:28,062 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@73a8da0f]
DEBUG 2021-09-05 11:31:28,065 mybatis.RoleMapper.getRole: ==>  Preparing: select id, role_name as roleName, note from t_role where id = ?
DEBUG 2021-09-05 11:31:28,098 mybatis.RoleMapper.getRole: ==> Parameters: 1(Long)
DEBUG 2021-09-05 11:31:28,128 mybatis.RoleMapper.getRole: <==      Total: 1
 INFO 2021-09-05 11:31:28,129 mybatis.SqlSessionFactoryUtils: John
DEBUG 2021-09-05 11:31:28,129 mybatis.RoleMapper.findRoles: ==>  Preparing: select id, role_name as roleName, note from t_role where role_name like concat('%', ?, '%')
DEBUG 2021-09-05 11:31:28,130 mybatis.RoleMapper.findRoles: ==> Parameters: John(String)
DEBUG 2021-09-05 11:31:28,131 mybatis.RoleMapper.findRoles: <==      Total: 1
 INFO 2021-09-05 11:31:28,131 mybatis.SqlSessionFactoryUtils: Hello World!
DEBUG 2021-09-05 11:31:28,131 mybatis.RoleMapper.findRoles2: ==>  Preparing: select id, role_name, note from t_role where note like concat('%', ?, '%')
 INFO 2021-09-05 11:31:28,132 mybatis.MyTypeHandler: 设置string参数【Hello World!】
DEBUG 2021-09-05 11:31:28,132 mybatis.RoleMapper.findRoles2: ==> Parameters: Hello World!(String)
 INFO 2021-09-05 11:31:28,134 mybatis.MyTypeHandler: 读取string参数1【Hello World!】
DEBUG 2021-09-05 11:31:28,134 mybatis.RoleMapper.findRoles2: <==      Total: 1
 INFO 2021-09-05 11:31:28,135 mybatis.SqlSessionFactoryUtils: John
DEBUG 2021-09-05 11:31:28,135 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@73a8da0f]
DEBUG 2021-09-05 11:31:28,135 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@73a8da0f]
DEBUG 2021-09-05 11:31:28,135 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 1940445711 to pool.

Process finished with exit code 0

枚举typeHandler

在绝多大数情况下，typeHandler因为枚举而使用，MyBatis已经定义了两个类作为枚举类型的支持：

EnumOrdinalTypeHandler
EnumTypeHandler

数据库预先插入一条数据：

1	insert t_user values(1, 'zhangsan', '123456', '1', '13699988874', '0755-88888888', 'zhangsan@163.com', 'note...');

UserMapper.xml

EnumOrdinalTypeHandler方式

EnumOrdinalTypeHandler是按MyBatis根据枚举数组下标索引的方式进行匹配的，也是枚举类型的默认转换类，它要求数据库返回一个整数作为其下标，它会根据下标找到对应的枚举类型。
详见运行结果①中，sex为1返回的是FEMAL的（0，‘女’)

<?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="mybatis.UserMapper">
    <resultMap id="userMapper" type="user">
        <result property="id" column="id"/>
        <result property="userName" column="user_name"/>
        <result property="password" column="password"/>
        <result property="sex" column="sex" typeHandler="org.apache.ibatis.type.EnumOrdinalTypeHandler"/>
        <result property="mobile" column="mobile"/>
        <result property="tel" column="tel"/>
        <result property="email" column="email"/>
        <result property="note" column="note"/>
    </resultMap>

    <select id="getUser" resultMap="userMapper" parameterType="long">
        select id, user_name, password, sex, mobile, tel, email, note from t_user where id = #{id}
    </select>

</mapper>

EnumTypeHandler方式

EnumTypeHandler会把使用的名称转化为对应的枚举，比如它会根据数据库返回的字符串“MALE”，进行Enum.valueOf(SexEnum.class, “MALE”);转换；将对应sex字段改成”MALE”进行测试，见运行结果②；

<?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="mybatis.UserMapper">
    <resultMap id="userMapper" type="user">
        <result property="id" column="id"/>
        <result property="userName" column="user_name"/>
        <result property="password" column="password"/>
        <result property="sex" column="sex" typeHandler="org.apache.ibatis.type.EnumTypeHandler"/>
        <result property="mobile" column="mobile"/>
        <result property="tel" column="tel"/>
        <result property="email" column="email"/>
        <result property="note" column="note"/>
    </resultMap>

    <select id="getUser" resultMap="userMapper" parameterType="long">
        select id, user_name, password, sex, mobile, tel, email, note from t_user where id = #{id}
    </select>

</mapper>

SexEnum

package mybatis;

public enum SexEnum {

    MALE(1, "男"),
    FEMALE(0, "女");

    private int id;
    private String name;

    private SexEnum(int id, String name){ //私有构造器
        this.id = id;
        this.name = name;
    }

    public SexEnum getSexById(int id){
        for(SexEnum sex : SexEnum.values()){
            if(sex.getId() == id) return sex;
        }
        return null;
    }

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

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

    public java.lang.String getName() {
        return name;
    }

    public int getId() {
        return id;
    }
}

User

package mybatis;

public class User {
    private Long id;
    private String userName;
    private String password;
    private SexEnum sex;
    private String mobile;
    private String tel;
    private String email;
    private String note;

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

    public void setNote(String note) {
        this.note = note;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setSex(SexEnum sex) {
        this.sex = sex;
    }

    public void setTel(String tel) {
        this.tel = tel;
    }

    public String getNote() {
        return note;
    }

    public Long getId() {
        return id;
    }

    public String getUserName() {
        return userName;
    }

    public SexEnum getSex() {
        return sex;
    }

    public String getEmail() {
        return email;
    }

    public String getMobile() {
        return mobile;
    }

    public String getPassword() {
        return password;
    }

    public String getTel() {
        return tel;
    }
}

UserMapper

package mybatis;

public interface UserMapper {
    User getUser(Long id);
}

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org/DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- 别名 -->
    <typeAliases>
        <typeAlias alias="role" type="mybatis.Role"/>
        <typeAlias alias="user" type="mybatis.User"/>
    </typeAliases>
    <!-- 数据库环境 -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--  映射文件  -->
    <mappers>
        <mapper resource="mybatis\RoleMapper.xml"/>
        <mapper resource="mybatis\UserMapper.xml"/>
    </mappers>
</configuration>

SqlSessionFactoryUtils

package mybatis;

import com.alibaba.fastjson.JSON;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class SqlSessionFactoryUtils {
    private final static Class<SqlSessionFactoryUtils> LOCK = SqlSessionFactoryUtils.class;

    private static SqlSessionFactory sqlSessionFactory = null;

    private SqlSessionFactoryUtils(){} //单例模式

    public static SqlSessionFactory getSqlSessionFactory(){
        synchronized (LOCK){
            if(sqlSessionFactory != null) return sqlSessionFactory;
            String resource = "mybatis\\mybatis-config.xml";
            InputStream inputStream;
            try{
                inputStream = Resources.getResourceAsStream(resource);
                sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            }catch (IOException e){
                e.printStackTrace();
                return null;
            }
            return sqlSessionFactory;
        }
    }

    public static SqlSession openSqlSession(){
        if(sqlSessionFactory == null) getSqlSessionFactory();
        return sqlSessionFactory.openSession();
    }
    public static void main(String[] args){
        //log4j.properties默认是在src目录下，如果不是需要重新设置
        //加载log4j的配置文件
//        FileInputStream fileInputStream = null;
//        try{
//            Properties properties = new Properties();
//            fileInputStream = new FileInputStream("src\\mybatis\\log4j.properties");
//            properties.load(fileInputStream);
//            PropertyConfigurator.configure(properties);
//        }catch (Exception e){
//            e.printStackTrace();
//        }finally {
//            if(fileInputStream != null){
//                try{
//                    fileInputStream.close();
//                }catch (IOException e){
//                    e.printStackTrace();
//                }
//            }
//        }
        Logger logger = Logger.getLogger(SqlSessionFactoryUtils.class);
        SqlSession sqlSession = null;
        try{
            sqlSession = SqlSessionFactoryUtils.openSqlSession();
//            RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
//            Role role = roleMapper.getRole(1L);
//            //System.out.println(JSON.toJSONString(role));
//            logger.info(role.getRoleName());
//            List<Role> list= roleMapper.findRoles("John");
//            logger.info(list.get(0).getNote());
//            List<Role> list1 = roleMapper.findRoles2("Hello World!");
//            logger.info(list1.get(0).getRoleName());

            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            User user = userMapper.getUser(1L);
            logger.info(user.getSex().getName());

        }finally {
            if(sqlSession != null) sqlSession.close();
        }
    }
}

运行结果

结果①

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=59199:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-05 15:06:38,169 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-05 15:06:38,183 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 15:06:38,183 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 15:06:38,183 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 15:06:38,183 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 15:06:38,264 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-05 15:06:38,619 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 1099717276.
DEBUG 2021-09-05 15:06:38,620 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@418c5a9c]
DEBUG 2021-09-05 15:06:38,623 mybatis.UserMapper.getUser: ==>  Preparing: select id, user_name, password, sex, mobile, tel, email, note from t_user where id = ?
DEBUG 2021-09-05 15:06:38,657 mybatis.UserMapper.getUser: ==> Parameters: 1(Long)
DEBUG 2021-09-05 15:06:38,685 mybatis.UserMapper.getUser: <==      Total: 1
 INFO 2021-09-05 15:06:38,685 mybatis.SqlSessionFactoryUtils: 女
DEBUG 2021-09-05 15:06:38,686 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@418c5a9c]
DEBUG 2021-09-05 15:06:38,686 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@418c5a9c]
DEBUG 2021-09-05 15:06:38,687 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 1099717276 to pool.

Process finished with exit code 0

结果②

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=63365:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-05 15:45:56,478 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-05 15:45:56,492 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 15:45:56,492 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 15:45:56,492 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 15:45:56,492 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 15:45:56,573 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-05 15:45:56,940 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 33233312.
DEBUG 2021-09-05 15:45:56,940 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1fb19a0]
DEBUG 2021-09-05 15:45:56,943 mybatis.UserMapper.getUser: ==>  Preparing: select id, user_name, password, sex, mobile, tel, email, note from t_user where id = ?
DEBUG 2021-09-05 15:45:56,973 mybatis.UserMapper.getUser: ==> Parameters: 1(Long)
DEBUG 2021-09-05 15:45:57,003 mybatis.UserMapper.getUser: <==      Total: 1
 INFO 2021-09-05 15:45:57,004 mybatis.SqlSessionFactoryUtils: 男
 INFO 2021-09-05 15:45:57,005 mybatis.SqlSessionFactoryUtils: 1
DEBUG 2021-09-05 15:45:57,005 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1fb19a0]
DEBUG 2021-09-05 15:45:57,006 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1fb19a0]
DEBUG 2021-09-05 15:45:57,006 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 33233312 to pool.

Process finished with exit code 0

自定义枚举typeHandler

MyBatis内部提供的两种转换的typeHandler有很大局限，更多时候需要我们使用自定义的typeHandler

1 2	update t_user set sex='1' where sex = 'MALE'; alter table t_user modify sex int(10);

package mybatis;

import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;
import org.apache.ibatis.type.TypeHandler;

import java.sql.*;

@MappedTypes(SexEnum.class)
@MappedJdbcTypes(JdbcType.INTEGER)
public class SexEnumTypeHandler implements TypeHandler<SexEnum> {
    @Override
    public void setParameter(PreparedStatement preparedStatement, int i, SexEnum parameter, JdbcType jdbcType) throws SQLException {
        preparedStatement.setInt(i, parameter.getId());
    }

    @Override
    public SexEnum getResult(ResultSet resultSet, String columnName) throws SQLException {
        int id = resultSet.getInt(columnName);
        return SexEnum.getSexById(id);
    }

    @Override
    public SexEnum getResult(ResultSet resultSet, int columnIndex) throws SQLException {
        int id = resultSet.getInt(columnIndex);
        return SexEnum.getSexById(id);
    }

    @Override
    public SexEnum getResult(CallableStatement callableStatement, int columnIndex) throws SQLException {
        int id = callableStatement.getInt(columnIndex);
        return SexEnum.getSexById(id);
    }
}

这里涉及到两个注解，如下：

@MappedTypes：指定与其关联的 Java类型列表。如果在javaType 属性中也同时指定，则注解上的配置将被忽略。
@MappedJdbcTypes：指定与其关联的JDBC 类型列表。如果在jdbcType 属性中也同时指定，则注解上的配置将被忽略。

修改UserMapper中的typeHandler，执行结果如下：

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=51458:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-05 16:38:30,503 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-05 16:38:30,519 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 16:38:30,519 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 16:38:30,519 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 16:38:30,519 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 16:38:30,621 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-05 16:38:30,967 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 33233312.
DEBUG 2021-09-05 16:38:30,967 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1fb19a0]
DEBUG 2021-09-05 16:38:30,971 mybatis.UserMapper.getUser: ==>  Preparing: select id, user_name, password, sex, mobile, tel, email, note from t_user where id = ?
DEBUG 2021-09-05 16:38:30,998 mybatis.UserMapper.getUser: ==> Parameters: 1(Long)
DEBUG 2021-09-05 16:38:31,023 mybatis.UserMapper.getUser: <==      Total: 1
 INFO 2021-09-05 16:38:31,024 mybatis.SqlSessionFactoryUtils: 男
 INFO 2021-09-05 16:38:31,024 mybatis.SqlSessionFactoryUtils: 1
DEBUG 2021-09-05 16:38:31,024 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1fb19a0]
DEBUG 2021-09-05 16:38:31,025 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1fb19a0]
DEBUG 2021-09-05 16:38:31,025 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 33233312 to pool.

Process finished with exit code 0

文件操作（不太常用）

使用Blob字段，用于存入文件

create table t_file(
id int(12) not null auto_increment,
content blob not null,
primary key(id)  
);

public class TestFile{
  long id;
  byte[] content;
  //setter and getter
}

<?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="mybatis.FileMapper">
    <resultMap id="fileMapper" type="mybatis.TestFile">
      <id column="id" property="id"/>
      <id column="content" property="content" typeHandler="org.apache.ibatis.type.BlobTypeHandler"/> <!-可以不用加typeHanlder，因为MyBatis可以自动检测--->
    </resultMap>

    <select id="getUser" resultMap="fileMapper" parameterType="long">
        select id, content from t_file  where id = #{id}
    </select>

    <insert id="insertFile" parameterType="mybatis.TestFile">
      insert into t_file(content) values(#{content})
    </insert>
</mapper>

ObjectFactory（对象工厂）

当创建结果集时，MyBatis会使用一个对象工厂来完成创建这个结果集实例。在默认的情况下，MyBatis会使用其定义的对象工厂——DefaultObjectFactory(org.apache.ibatis.reflection.factory.DefaultObjectFactory)来完成对应的工作。

MyBatis允许注册自定义的ObjectFactory，需要实现接口org.apache.ibatis.reflection.factory.ObjectFactory，并给予配置。一般会考虑集成系统已经实现好的DefaultObjectFactory，通过一定的改写来完成我们所需要的工作。

MyObjectFactory

package mybatis;

import org.apache.ibatis.reflection.factory.DefaultObjectFactory;
import org.apache.log4j.Logger;

import java.util.List;
import java.util.Properties;

public class MyObjectFactory extends DefaultObjectFactory {

    private static final long serialVersionUID = -8855122346740914948L;

    Logger logger = Logger.getLogger(MyObjectFactory.class);

    private Object temp = null;

    @Override
    public void setProperties(Properties properties) {
        super.setProperties(properties);
        logger.info("初始化参数：【" + properties.toString() +"】");
    }

    @Override
    public <T> T create(Class<T> type) {
        T result =  super.create(type);
        logger.info("创建对象：" + result.toString());
        logger.info("是否和上次创建的是同一个对象：【" + (temp == result) + "】");
        return result;
    }

    @Override
    public <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
        T result = super.create(type, constructorArgTypes, constructorArgs);
        logger.info("创建对象：" + result.toString());
        temp = result;
        return result;
    }

    @Override
    public <T> boolean isCollection(Class<T> type) {
        return super.isCollection(type);
    }
}

mybatis-config.xml

1
2
3

<objectFactory type="mybatis.MyObjectFactory">
    <property name="propl" value="value1"/>
</objectFactory>

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=55502:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar mybatis.SqlSessionFactoryUtils
 INFO 2021-09-05 20:53:52,376 mybatis.MyObjectFactory: 初始化参数：【{propl=value1}】
DEBUG 2021-09-05 20:53:52,395 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-05 20:53:52,408 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 20:53:52,408 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 20:53:52,408 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 20:53:52,408 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-05 20:53:52,516 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-05 20:53:52,864 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 1515403487.
DEBUG 2021-09-05 20:53:52,865 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5a5338df]
DEBUG 2021-09-05 20:53:52,867 mybatis.UserMapper.getUser: ==>  Preparing: select id, user_name, password, sex, mobile, tel, email, note from t_user where id = ?
DEBUG 2021-09-05 20:53:52,893 mybatis.UserMapper.getUser: ==> Parameters: 1(Long)
 INFO 2021-09-05 20:53:52,918 mybatis.MyObjectFactory: 创建对象：[]
 INFO 2021-09-05 20:53:52,918 mybatis.MyObjectFactory: 创建对象：[]
 INFO 2021-09-05 20:53:52,919 mybatis.MyObjectFactory: 是否和上次创建的是同一个对象：【true】
 INFO 2021-09-05 20:53:52,920 mybatis.MyObjectFactory: 创建对象：mybatis.User@2f62ea70
 INFO 2021-09-05 20:53:52,920 mybatis.MyObjectFactory: 创建对象：mybatis.User@2f62ea70
 INFO 2021-09-05 20:53:52,920 mybatis.MyObjectFactory: 是否和上次创建的是同一个对象：【true】
DEBUG 2021-09-05 20:53:52,921 mybatis.UserMapper.getUser: <==      Total: 1
 INFO 2021-09-05 20:53:52,922 mybatis.SqlSessionFactoryUtils: 男
 INFO 2021-09-05 20:53:52,922 mybatis.SqlSessionFactoryUtils: 1
DEBUG 2021-09-05 20:53:52,922 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5a5338df]
DEBUG 2021-09-05 20:53:52,922 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5a5338df]
DEBUG 2021-09-05 20:53:52,922 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 1515403487 to pool.

Process finished with exit code 0

插件

插件是MyBatis中最强大和灵活的组件，同时也是最复杂、最难以使用的组件，而且其十分危险，因为它将覆盖MyBatis底层对象的核心方法和属性。如果操作不对那个将产生严重后果，甚至是摧毁MyBatis框架。待跟进。

enviroments（运行环境）

在MyBatis中，运行环境主要的作用是配置数据库信息，它可以配置多个数据库，一般而言只需要配置其中的一个就可以了。其下面又分为两个可配置的元素：

事务管理器（transactionManager）
数据源（dataSource）

<environment id="development">
    <transactionManager type="JDBC"/>
    <dataSource type="POOLED">
        <property name="driver" value="${database.driver}"/>
        <property name="url" value="${database.url}"/>
        <property name="username" value="${database.username}"/>
        <property name="password" value="${database.password}"/>
    </dataSource>
</environment>

transactionManager（事务管理器）

简介

在MyBatis中，transactionManger提供了两个实现类，它需要实现接口Transaction(org.apache.ibatis.transaction.Transaction)

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.transaction;

import java.sql.Connection;
import java.sql.SQLException;

public interface Transaction {
    Connection getConnection() throws SQLException;

    void commit() throws SQLException;

    void rollback() throws SQLException;

    void close() throws SQLException;

    Integer getTimeout() throws SQLException;
}

其主要工作就是提交、回滚和关闭数据库的事务

MyBatis为Transaction提供了两个实现类：

JdbcTransaction
ManagedTransaction

1 2	<transactionManager type="JDBC"/> <transactionManager type="MANAGED"/>

JDBC使用JdbcTransactionFactory生成的JdbcTransaction对象实现。它是以JDBC的方式对数据库的提交和回滚进行操作；
MANAGED使用ManagedTransactionFactory生成的ManagedTransaction对象实现。它的提交和回滚方法不用任何操作，而是把事务交给容器处理。在默认情况下，它会关闭连接，然而一些容器并不希望这样，因此需要closeConnection属性设置为false来组织它默认的关闭行为。

自定义事务工厂

可以通过自定义事务规则，满足特殊的需求。

1	<transactionManager type="mybatis.MyTransactionFactory"/>

package mybatis;

import org.apache.ibatis.session.TransactionIsolationLevel;
import org.apache.ibatis.transaction.Transaction;
import org.apache.ibatis.transaction.jdbc.JdbcTransaction;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;


public class MyTransaction extends JdbcTransaction implements Transaction {
    public MyTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit){
        super(ds, desiredLevel, desiredAutoCommit);
    }

    public MyTransaction(Connection connection){
        super(connection);
    }

    @Override
    public Connection getConnection() throws SQLException {
        return super.getConnection();
    }

    @Override
    public void commit() throws SQLException {
        super.commit();
    }

    @Override
    public void rollback() throws SQLException {
        super.rollback();
    }

    @Override
    public void close() throws SQLException {
        super.close();
    }

    @Override
    public Integer getTimeout() throws SQLException {
        return super.getTimeout();
    }
}

environment数据源环境

environment的主要作用是配置数据库，数据库通过三个工厂类来提供：

PooledDataSourceFactory产生PooledDataSource类对象；
UnpooledDataSourceFactory产生UnpooledDataSource类对象；
JndiDataSourceFactory则会根据JNDI的信息拿到外部容器实现的数据库连接对象。

无论如何这三个工厂类，最后生成的产品都会是一个实现了DataSource接口的数据库连接对象。

1
2
3

<dataSource type="POOLED">
<dataSource type="UNPOOLED">
<dataSource type="JNDI">

UNPOOLED

采用非数据库池的管理方式，每次请求都会打开一个新的数据库连接，所以创建会比较慢。
可配置的属性：

driver数据库驱动名，比如MySQL的com.mysql.jc.jdbc.Driver
url连接数据库的URL
username用户名
password密码
defaultTransactionIsolationLevel默认的连接事务隔离级别

POOLED

利用池的概念将JDBC的Connection对象组织起来，它开始会有一些空置，并且已经连接好的数据库连接，所以请求时，无须再建立和验证，省去了创建新的连接实例时所必需的初始化和认证时间。它还控制最大连接数，避免过多的连接导致系统瓶颈。
除了UNPOOLED下的属性外，会有更多属性用来配置POOLED的数据源：

poolMaximumActiveConnections是在任意时间都存在的活动（也就是正在使用）连接数量，默认值为0；
poolMaximumIdleConnections是任意时间可能存在的空闲连接数；
poolMaximumCheckoutTime在被强制返回之前，池中连接被检出（Checked out）的时间，默认值为20000毫秒；
poolTimeToWait是一个底层设置，如果获取连接花费相当长的时间，它会给连接池打印状态日志，并重新尝试获取一个连接（避免在误配置的情况下一直失败），默认值为20000毫秒；
poolPingQuery为发送到数据库的侦测查询，用来检验连接是否处在正常工作秩序中，并准备接受请求。默认是“NO PING QUERY SET”，这会导致多数数据库驱动失败时带有一个恰当的错误消息。
poolPingEnabled为是否启用侦测查询。若开启，也必须使用一个可执行的SQL语句设置poolPingQuery属性（最好是一个非常快的SQL），默认值为false；
poolPingConnectionsNotUsedFor为配置poolPingQuery的使用额度。这可以被设置成匹配具体的数据库连接超时时间，来避免不必要的侦测，默认值为0（即所有连接每一时刻都被侦测——仅当poolPingEnabled为true时使用）。

JNDI

数据源JNDI的实现为了能在如EJB或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个JNDI上下文的引用。这种数据源配置只需要两个属性：

initial_context用来在InitialContext中寻找上下文（即，initialContext.lookup(initial_context))。initial_context是个可选属性，如果忽略，那么data_source属性将会直接从InitialContext中寻找；
data_source是引用数据源实例位置上下文的路径。当提供initial_context配置时，data_source会在其返回的上下文中进行查找；当没有提供Initial_context时，data_source直接在InitialContext中查找。

第三方数据源

MyBatis也支持第三方数据源，例如使用DBCP数据源，那么需要提供一个自定义的DataSourceFactory。

package mybatis;

import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.apache.ibatis.datasource.DataSourceFactory;

import javax.sql.DataSource;
import java.util.Properties;

public class DbcpDataSourceFactory implements DataSourceFactory {
    private Properties props = null;

    @Override
    public void setProperties(Properties properties) {
        this.props = properties;
    }

    @Override
    public DataSource getDataSource() {
        DataSource dataSource = null;
        try{
            dataSource = BasicDataSourceFactory.createDataSource(props);
        }catch (Exception e){
            e.printStackTrace();
        }
        return dataSource;
    }
}

配置

<dataSource type="mybatis.DbcpDataSourceFactory">
  <property name="driver" value="${database.driver}"/>
  <property name="url" value="${database.url}"/>
  <property name="username" value="${database.username}"/>
  <property name="password" value="${database.password}"/>
</dataSource>

databaseIdProvider数据库厂商标识

databaseIdProvider元素主要是支持多种不同厂商的数据库，虽然这个元素并不常用，但是在一些公司却十分有用，因为有些软件公司需要给不同的客户提供系统，使用何种数据库往往是由客户决定的。例如，软件公司默认的是MySQL数据库，而客户只打算使用Oracle。

使用系统默认的databaseIdProvider

<databaseIdProvider type="DB_VENDOR">
  <property name="Oracle" value="oracle"/>
  <property name="MySQL" value="mysql"/>
  <property name="DB2" value="db2"/>
</databaseIdProvider>

property元素属性：

name是数据库名称，如果不确定如何填写，那么可以使用JDBC创建其数据库连接对象Connection，然后通过代码connection.getMetaData().getDatabase.ProductName()获取。
value是数据库的别名，在MyBatis里可以通过这个别名标识一条SQL适用于哪种数据库运行。然后，改造映射器的SQL

配置文件中设置databaseId进行设置：

<select id="getRole" parameterType="long" resultType="role" databaseId="oracle">
  select id, role_name as roleName, note from t_role where id = #{id}
</select>

<select id="getRole" parameterType="long" resultType="role" databaseId="mysql">
  select id, role_name as roleName, note from t_Role where l=1 and id = #{id}
</select>

如果同时存在一条有databaseId和没有databaseId的标识会怎么样呢？
正常运行

<select id="getRole" parameterType="long" resultType="role" databaseId="oracle">
  select id, role_name as roleName, note from t_role where id = #{id}
</select>

<select id="getRole" parameterType="long" resultType="role">
  select id, role_name as roleName, note from t_Role where l=1 and id = #{id}
</select>

运行异常

<select id="getRole" parameterType="long" resultType="role" databaseId="oracle">
  select id, role_name as roleName, note from t_role where id = #{id}
</select>

<select id="getRole" parameterType="long" resultType="role" databaseId="db2">
  select id, role_name as roleName, note from t_Role where l=1 and id = #{id}
</select>

使用多数据库SQL时需要配置databaseIdProvidertype的属性。
当databaseIdProvidertype属性被配置时，系统会优先取到和数据库配置一致的SQL。
如果没有，则取没有databaseId的SQL，可以把它当做默认值。
如果还是取不到，则会抛出异常，说明无法匹配到对应的SQL。

不使用系统规则

package mybatis;

import org.apache.ibatis.mapping.DatabaseIdProvider;
import org.apache.log4j.Logger;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;


public class MyDatabaseIdProvider implements DatabaseIdProvider {

    private static final String DATABASE_TYPE_DB2 = "DB2";
    private static final String DATABASE_TYPE_MYSQL = "MySQL";
    private static final String DATABASE_TYPE_ORACLE = "Oracle";

    private Logger logger = Logger.getLogger(MyDatabaseIdProvider.class);

    @Override
    public void setProperties(Properties p) {
        logger.info(p);
    }

    @Override
    public String getDatabaseId(DataSource dataSource) throws SQLException {
        Connection connection = dataSource.getConnection();
        String dbProductName = connection.getMetaData().getDatabaseProductName();
        if(MyDatabaseIdProvider.DATABASE_TYPE_DB2.equals(dbProductName)){
            return "db2";
        }else if(MyDatabaseIdProvider.DATABASE_TYPE_MYSQL.equals(dbProductName)){
            return "mysql";
        }else if(MyDatabaseIdProvider.DATABASE_TYPE_ORACLE.equals(dbProductName)){
            return "oracle";
        }else return null;
    }
}

1 2	<databaseIdProvider type="mybatis.MyDatabaseIdProvider"> </databaseIdProvider>

引入映射器的方法

映射器是MyBatis最复杂、最核心的组件。

Mapper接口

package mybatis;

import java.util.List;

public interface RoleMapper {
    int insertRole(Role role);
    int deleteRole(Long id);
    int updateRole(Role role);
    Role getRole(Long id);
    List<Role> findRoles(String roleName);
    List<Role> findRoles2(String note);
}

Mapper.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="mybatis.RoleMapper">
    <resultMap id="roleMapper" type="role">
        <result property="id" column="id"/>
        <result property="roleName" column="role_name" jdbcType="VARCHAR" javaType="string"/>
        <result property="note" column="note" typeHandler="mybatis.MyTypeHandler"/>
    </resultMap>

    <insert id="insertRole" parameterType="role">
        insert into t_role(role_name, note) values(#{roleName}, #{note})
    </insert>

    <delete id="deleteRole" parameterType="long">
        delete from t_role where id = #{id}
    </delete>

    <update id="updateRole" parameterType="role">
        update t_role set role_name = #{roleName}, note = #{note} where id = #{id}
    </update>

    <select id="getRole" parameterType="long" resultType="role">
        select id, role_name as roleName, note from t_role where id = #{id}
    </select>

    <select id="findRoles" parameterType="string" resultType="role">
        select id, role_name as roleName, note from t_role
        where role_name like concat('%', #{roleName, jdbcType=VARCHAR, javaType=string}, '%')
    </select>

    <select id="findRoles2" parameterType="string" resultMap="roleMapper">
        select id, role_name, note from t_role
        where note like concat('%', #{note, typeHandler=mybatis.MyTypeHandler}, '%')
    </select>
</mapper>

引入方法

1
2
3

<mappers>
  <mapper resource="mybatis.RoleMapper.xml"/>
</mappers>

1
2
3

<mappers>
  <package name="mybatis.RoleMapper.xml"/>
</mappers>

<mappers>
  <mapper class="mybatis.RoleMapper"/>
  <mapper class="mybatis.UserMapper"/>
</mappers>

1
2
3

<mappers>
  <mapper url="file://D:/JavaTest/src/mybatis.RoleMapper.xml"/>
</mappers>

映射器

映射器是MyBatis最复杂且最终啊哟的组件，由一个接口加上XML文件组成

select元素

简介

元素	说明	备注
id	它和Mapper接口的命名空间组合起来是唯一的，供MyBatis调用	如果命名空间和id结合起来不唯一，MyBatis将会抛出异常
parameterType	可以给出类的全命名，也可以给出别名，但是别名必须是MyBatis内部定义或者自定义的	可以选择Java Bean、Map等简单的参数类型传递给SQL
resultType	定义类的全路径，在允许自动匹配的情况下，结果集将通过Java Bean的规范映射；或定义为int/double/float/map等参数；也可以使用别名，不能和resultMap同时使用	常用的参数之一
resultMap	映射集的英勇，将执行强大的映射功能。我们可以使用resultType和resultMap其中一个，resultMap能提供自定义映射规则的机会。	MyBatis最复杂的元素，可以配置映射规则、级联、typeHandler等
flushCache	它的作用是在调用SQL后，是否要求MyBatis清空之前查询本地缓存和二级缓存	取值为布尔值。true\|false。默认值为false
useCache	启动二级缓存开关，是否要求MyBatis将此次结果缓存	true\|false，默认true
timeout	设置超时参数，超时将抛出异常，单位秒
fetchSize	获取记录的总条数设定
statementType	告诉MyBatis使用哪个JDBC的Statement工作，取值为STATEMENT(Statement)、PREPARED(PreparedStatement)、CALLABLE(CallableStatement)	默认PREPARED
resultSetType	对JDBC的resultSet接口而言，它的值包括FORWARD_ONLY（游标允许向前访问）、SCROLL_SENSITIVE（双向滚动、但不及时更新，就是如果数据库里的数据修改过，并不在resultSet中反映出来）、SCROLL_INSENSITIVE（双向滚动，并及时跟踪数据库的更新，以便更新resultSet中的数据）	默认是数据库厂商提供的JDBC驱动所设置的
databaseId	数据库厂商标识	提供多种数据库支持
resultOrdered	仅适用于嵌套结果select语句。如果为true，就是假设包含了嵌套结果集或是分组了，当返回一个主结果行时，就不能应用前面结果集了。这就确保了在获取嵌套的结果集时不至于导致内存不够用	true\|false, 默认false
resultSets	适合于多个结果集的情况，它将列出执行SQL后每个结果集的名称，每个名称之间用逗号分隔	很少使用

自动映射和驼峰映射

MyBatis提供了自动映射功能，在默认情况下自动映射功能是开启的，使用它的好处在于能有效减少大量的映射配置，从而减少工作量。

在setting元素中有两个可以配置的选项autoMappingBehavior和mapUpderscoreToCamelCase，控制自动映射和驼峰映射的开关。
一般而言，自动映射会使用得多一些，而驼峰映射要求比较严苛，所以字啊实际中应用不算太广。

public class Role{
  private Long id;
  private String roleName;
  private String note;
}

1
2
3

<select id="getRole" parameterType="long" resultType="mybatis.Role">
  select id, role_name as roleName, note from t_role where id = #{id}
</select>

role_name被别名roleName代替，和POJO的属性名称保持一致，MyBatis将其映射到POJO的属性roleName上，自动完成映射。
如果不用as roleName，则按照驼峰命名规则进行了匹配，如果驼峰映射开启的话。

传递多个参数

不带注解传递

package mybatis;

import java.util.List;
import java.util.Map;

public interface RoleMapper {
    List<Role> findRolesByMap(Map<String, Object> parameterMap);
}

<select id="findRolesByMap" parameterType="map" resultType="role">
        select id, role_name as roleName, note from t_role
        where role_name like concat('%', #{roleName}, '%')
        and note like concat('%', #{note}, '%')
</select>

Map<String, Object> parameterMap = new HashMap<>();
parameterMap.put("roleName", "John");
parameterMap.put("note", "Hello World!");
List<Role> roles = roleMapper.findRolesByMap(parameterMap);
for(Role role:roles){
  logger.info(JSON.toJSON(role));
}

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=49861:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-06 17:13:27,146 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-06 17:13:27,161 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:13:27,161 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:13:27,161 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:13:27,161 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:13:27,249 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-06 17:13:27,627 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 417557780.
DEBUG 2021-09-06 17:13:27,627 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@18e36d14]
DEBUG 2021-09-06 17:13:27,630 mybatis.RoleMapper.findRolesByMap: ==>  Preparing: select id, role_name as roleName, note from t_role where role_name like concat('%', ?, '%') and note like concat('%', ?, '%')
DEBUG 2021-09-06 17:13:27,659 mybatis.RoleMapper.findRolesByMap: ==> Parameters: John(String), Hello World!(String)
DEBUG 2021-09-06 17:13:27,688 mybatis.RoleMapper.findRolesByMap: <==      Total: 1
 INFO 2021-09-06 17:13:27,751 mybatis.SqlSessionFactoryUtils: {"note":"Hello World!","roleName":"John","id":1}
DEBUG 2021-09-06 17:13:27,754 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@18e36d14]
DEBUG 2021-09-06 17:13:27,755 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@18e36d14]
DEBUG 2021-09-06 17:13:27,755 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 417557780 to pool.

Process finished with exit code 0

带注解传递

package mybatis;

import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

public interface RoleMapper {
    List<Role> findRolesByAnnotation(@Param("roleName") String roleName, @Param("note") String note);
}

List<Role> roles = roleMapper.findRolesByAnnotation("John", "Hello World!");
for(Role role:roles){
  logger.info(JSON.toJSON(role));
}

<select id="findRolesByAnnotation" resultType="role">
    select id, role_name as roleName, note from t_role
    where role_name like concat('%', #{roleName}, '%')
    and note like concat('%', #{note}, '%')
</select>

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=64453:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-06 17:24:17,792 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-06 17:24:17,806 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:24:17,806 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:24:17,806 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:24:17,806 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:24:17,886 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-06 17:24:18,230 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 417557780.
DEBUG 2021-09-06 17:24:18,231 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@18e36d14]
DEBUG 2021-09-06 17:24:18,233 mybatis.RoleMapper.findRolesByAnnotation: ==>  Preparing: select id, role_name as roleName, note from t_role where role_name like concat('%', ?, '%') and note like concat('%', ?, '%')
DEBUG 2021-09-06 17:24:18,258 mybatis.RoleMapper.findRolesByAnnotation: ==> Parameters: John(String), Hello World!(String)
DEBUG 2021-09-06 17:24:18,286 mybatis.RoleMapper.findRolesByAnnotation: <==      Total: 1
 INFO 2021-09-06 17:24:18,352 mybatis.SqlSessionFactoryUtils: {"note":"Hello World!","roleName":"John","id":1}
DEBUG 2021-09-06 17:24:18,355 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@18e36d14]
DEBUG 2021-09-06 17:24:18,356 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@18e36d14]
DEBUG 2021-09-06 17:24:18,356 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 417557780 to pool.

Process finished with exit code 0

Java Bean传递

注解的方式在参数数量较多的时候，使用起来就比较麻烦，为此，MyBatis还提供传递Java Bean的形式；

package mybatis;

import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;

public interface RoleMapper {
    List<Role> findRolesByBean(RoleParams roleParams);
}

<select id="findRolesByBean" parameterType="mybatis.RoleParams" resultType="role">
    select id, role_name as roleName, note from t_role
    where role_name like concat('%', #{roleName}, '%')
    and note like concat('%', #{note}, '%')
</select>

RoleParams roleParams = new RoleParams();
roleParams.setRoleName("John");
roleParams.setNote("Hello World!");
List<Role> roles = roleMapper.findRolesByBean(roleParams);
for(Role role:roles){
  logger.info(JSON.toJSON(role));
}
``

运行结果
```java
"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=54280:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-06 17:32:56,668 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-06 17:32:56,685 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:32:56,685 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:32:56,685 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:32:56,685 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 17:32:56,769 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-06 17:32:57,122 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 332699949.
DEBUG 2021-09-06 17:32:57,122 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@13d4992d]
DEBUG 2021-09-06 17:32:57,125 mybatis.RoleMapper.findRolesByBean: ==>  Preparing: select id, role_name as roleName, note from t_role where role_name like concat('%', ?, '%') and note like concat('%', ?, '%')
DEBUG 2021-09-06 17:32:57,155 mybatis.RoleMapper.findRolesByBean: ==> Parameters: John(String), Hello World!(String)
DEBUG 2021-09-06 17:32:57,180 mybatis.RoleMapper.findRolesByBean: <==      Total: 1
 INFO 2021-09-06 17:32:57,243 mybatis.SqlSessionFactoryUtils: {"note":"Hello World!","roleName":"John","id":1}
DEBUG 2021-09-06 17:32:57,246 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@13d4992d]
DEBUG 2021-09-06 17:32:57,247 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@13d4992d]
DEBUG 2021-09-06 17:32:57,247 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 332699949 to pool.

Process finished with exit code 0

混合传递方式

1
2
3

public interface RoleMapper {
    List<Role> findByMix(@Param("params") RoleParams roleParams, @Param("page") PageParams pageParams);
}

RoleParams roleParams = new RoleParams();
roleParams.setRoleName("John");
roleParams.setNote("Hello World!");
PageParams pageParams = new PageParams();
pageParams.setLimit(1);
pageParams.setStart(0);
List<Role> roles = roleMapper.findByMix(roleParams, pageParams);
logger.info("findByMix");
for(Role role:roles){
  logger.info(JSON.toJSON(role));
}

<select id="findByMix" resultType="role">
    select id, role_name as roleName, note from t_role
    where role_name like
    concat('%', #{params.roleName}, '%')
    and note like concat('%', #{params.note}, '%')
    limit #{page.start}, #{page.limit}
</select>

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=56202:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-06 19:30:29,420 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-06 19:30:29,434 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 19:30:29,434 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 19:30:29,434 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 19:30:29,434 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 19:30:29,521 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-06 19:30:29,867 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 1115170891.
DEBUG 2021-09-06 19:30:29,867 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@4278284b]
DEBUG 2021-09-06 19:30:29,869 mybatis.RoleMapper.findByMix: ==>  Preparing: select id, role_name as roleName, note from t_role where role_name like concat('%', ?, '%') and note like concat('%', ?, '%') limit ?, ?
DEBUG 2021-09-06 19:30:29,895 mybatis.RoleMapper.findByMix: ==> Parameters: John(String), Hello World!(String), 0(Integer), 1(Integer)
DEBUG 2021-09-06 19:30:29,918 mybatis.RoleMapper.findByMix: <==      Total: 1
 INFO 2021-09-06 19:30:29,919 mybatis.SqlSessionFactoryUtils: findByMix
 INFO 2021-09-06 19:30:29,984 mybatis.SqlSessionFactoryUtils: {"note":"Hello World!","roleName":"John","id":1}
DEBUG 2021-09-06 19:30:29,987 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@4278284b]
DEBUG 2021-09-06 19:30:29,988 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@4278284b]
DEBUG 2021-09-06 19:30:29,988 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 1115170891 to pool.

Process finished with exit code 0

总结

使用map传递参数导致了业务可读性的丧失，导致后续扩展和维护的困难，在实际的应用中要果断废弃这种方式；
使用@Param注解传递多个参数，受到参数个数（n）的影响。当n $\leq$ 5 时，这是最佳的传参方式，它比用Java Bean更好，因为它更加直观；当 n $\ge$ 5 时，多个参数讲给调用带来困难，此时不推荐使用它。
当参数个数多于5个时，建议使用JavaBean方式。
对于使用混合参数的，姚明全参数的合理性。

使用resultMap映射结果集

自动映射和驼峰映射规则比较简单，无法定义多的属性，比如typeHandler、级联等。为了支持复杂的映射，select元素提供了resultMap属性。

resultMap元素定义了一个roleMap，它的属性id代表它的标识，type代表使用哪个类作为其映射的类，可以使别名或者全限定名，role是mybatis.Role的别名
它的子元素id代表resultMap的主键，而result代表其属性，id和result元素的属性property代表POJO的属性名称，而column代表SQL的列名。把POJO的属性和SQL的列名做对应，例如POJO的属性roleName，就用SQL的列名role_name建立映射关系。
在select元素中的属性resultMap指定了采用哪个resultMap作为其映射规则。

<?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="mybatis.RoleMapper">
    <resultMap id="roleMapper" type="role">
        <id property="id" column="id"/>
        <result property="roleName" column="role_name" jdbcType="VARCHAR" javaType="string"/>
        <result property="note" column="note" typeHandler="mybatis.MyTypeHandler"/>
    </resultMap>
    <select id="findRoles2" parameterType="string" resultMap="roleMapper">
        select id, role_name, note from t_role
        where note like concat('%', #{note, typeHandler=mybatis.MyTypeHandler}, '%')
    </select>
</mapper>

分页参数RowBounds

MyBatis不仅支持分页，它还内置了一个专门处理分页的类——RowBounds。源码如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.session;

public class RowBounds {
    public static final int NO_ROW_OFFSET = 0;
    public static final int NO_ROW_LIMIT = 2147483647;
    public static final RowBounds DEFAULT = new RowBounds();
    private final int offset;
    private final int limit;

    public RowBounds() {
        this.offset = 0;
        this.limit = 2147483647;
    }

    public RowBounds(int offset, int limit) {
        this.offset = offset;
        this.limit = limit;
    }

    public int getOffset() {
        return this.offset;
    }

    public int getLimit() {
        return this.limit;
    }
}

mapper.xml映射器文件中没有任何关于RowBounds参数的信息，它是MyBatis的一个附加参数，MyBatis会自动识别它，据此进行分页。

<select id="findByRowBounds" resultType="role">
    select id, role_name as roleName, note from t_role
    where role_name like concat('%', #{roleName}, '%')
    and note like concat('%', #{note}, '%')
</select>

RoleParams roleParams = new RoleParams();
roleParams.setRoleName("John");
roleParams.setNote("Hello World!");
RowBounds rowBounds = new RowBounds(0, 20);
List<Role> roles = roleMapper.findByRowBounds("John", "Hello World!", rowBounds);
logger.info("findByRowBounds");
for(Role role:roles){
    logger.info(JSON.toJSON(role));
}

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=59806:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-06 20:26:49,807 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-06 20:26:49,821 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 20:26:49,821 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 20:26:49,821 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 20:26:49,821 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 20:26:49,911 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-06 20:26:50,272 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 156710276.
DEBUG 2021-09-06 20:26:50,272 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@9573584]
DEBUG 2021-09-06 20:26:50,275 mybatis.RoleMapper.findByRowBounds: ==>  Preparing: select id, role_name as roleName, note from t_role where role_name like concat('%', ?, '%') and note like concat('%', ?, '%')
DEBUG 2021-09-06 20:26:50,306 mybatis.RoleMapper.findByRowBounds: ==> Parameters: John(String), Hello World!(String)
DEBUG 2021-09-06 20:26:50,333 mybatis.RoleMapper.findByRowBounds: <==      Total: 2
 INFO 2021-09-06 20:26:50,334 mybatis.SqlSessionFactoryUtils: findByRowBounds
 INFO 2021-09-06 20:26:50,396 mybatis.SqlSessionFactoryUtils: {"note":"Hello World!","roleName":"John","id":1}
 INFO 2021-09-06 20:26:50,401 mybatis.SqlSessionFactoryUtils: {"note":"OOOO Hello World! XXX","roleName":"John","id":2}
DEBUG 2021-09-06 20:26:50,401 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@9573584]
DEBUG 2021-09-06 20:26:50,401 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@9573584]
DEBUG 2021-09-06 20:26:50,401 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 156710276 to pool.

Process finished with exit code 0

insert元素

简介

属性	描述	备注
id	SQL编号，用于标识这条SQL	命名空间+id+databaseId唯一，否则MyBatis会抛出异常
parameterType	同select
flushCache	同select
timeout
statementType
useGeneratedKyes	是否启动JDBC的getGeneratedKeys方法来去除由数据库内部生成的主键	默认false
keyProperty	（仅对insert和update有用）唯一标记一个属性，MyBatis会通过getGeneratedKeys的返回值，或者通过isnert语句的selectKey子元素设置它的剪枝。如果是符合主键，要把每一个名称用逗号隔开	默认值为unset, 不能和keyColumn连用
keyColumn	（仅对insert和update有用）通过生成的键值设置表中的列名，这个设置仅在某些数据库（像PostgreSQL）中是必须的，当主键列不是表中的第一列时需要设置。如果是符合主键，需要把一个名称用逗号隔开	不能和keyProperty连用
databaseId

简单insert语句应用

1
2
3

<insert id="insertRole" parameterType="role">
  insert into t_role(role_name, note) values(#{roleName}, #{note})
</insert>

主键回填

前一个插入应用中没有插入id列，因为MySQL中的表格才用了自增主键。但有时候还可能需要继续使用这个主键。

JDBC中的Statement对象在执行插入的SQL后，可以通过getGeneratedKeys方法获得数据库生成的主键（需要数据库驱动支持），这样便能达到获取主键的功能。

1
2
3

<insert id="insertRole" parameterType="role" useGeneratedKeys="true" keyProperty="id">
    insert into t_role(role_name, note) values(#{roleName}, #{note})
</insert>

userGeneratedKeys代表采用JDBC的Statement对象的getGeneratedKeys方法返回主键，而keyProperty则代表将用哪个POJO的属性去匹配这个主键，这里是id，说明它会用数据库生成的主键去幅值给这个POJO，测试主键回填的结果。

Role role = new Role();
role.setRoleName("Tom");
role.setNote("note_test");
roleMapper.insertRole(role);
sqlSession.commit();
logger.info("role id: " + role.getId().toString());

运行结果
如果如同前面简单的插入语句，下面的role.getId()为空，而不是这里的role id: 10

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=50726:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-06 22:04:20,537 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-06 22:04:20,553 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 22:04:20,553 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 22:04:20,553 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 22:04:20,553 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-06 22:04:20,640 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-06 22:04:21,041 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 1515403487.
DEBUG 2021-09-06 22:04:21,042 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5a5338df]
DEBUG 2021-09-06 22:04:21,045 mybatis.RoleMapper.insertRole: ==>  Preparing: insert into t_role(role_name, note) values(?, ?)
DEBUG 2021-09-06 22:04:21,079 mybatis.RoleMapper.insertRole: ==> Parameters: Tom(String), note_test(String)
DEBUG 2021-09-06 22:04:21,082 mybatis.RoleMapper.insertRole: <==    Updates: 1
DEBUG 2021-09-06 22:04:21,096 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Committing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5a5338df]
 INFO 2021-09-06 22:04:21,136 mybatis.SqlSessionFactoryUtils: role id: 10
DEBUG 2021-09-06 22:04:21,136 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5a5338df]
DEBUG 2021-09-06 22:04:21,136 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5a5338df]
DEBUG 2021-09-06 22:04:21,136 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 1515403487 to pool.

Process finished with exit code 0

自定义主键

有时候主键可能依赖于某些规则，比如取消主键id的递增规则，而将其修改为：

当角色表记录为空时，id设置为1；
当角色表记录不为空时，id设置为当前id加3；

<insert id="insertRole" parameterType="role">
    <selectKey keyProperty="id" resultType="long" order="BEFORE">
        select if (max(id) = null, 1, max(id) + 3) from t_role
    </selectKey>
    insert into t_role(id, role_name, note) values(#{id}, #{roleName}, #{note})
</insert>

keyProperty指定采用哪个属性作为POJO的主键
resutType告诉MyBatis将返回一个long型的结果集
order设置为BEFORE，说明它将于当前定义的SQL前执行。

update元素和delete元素

update元素和delete元素比较简单，其属性和insert差不多，执行完也会返回一个整数，用以标志改SQL语句影响了数据库的记录行数；

<delete id="deleteRole" parameterType="long">
    delete from t_role where id = #{id}
</delete>

<update id="updateRole" parameterType="role">
    update t_role set role_name = #{roleName}, note = #{note} where id = #{id}
</update>

sql元素

sql元素的作用在于可以定义一条SQL的一部分，方便后面的SQL应用它。
通常情况下要在select、insert等语句中反复编写它们，特别是那些字段较多的表更是如此。

<?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="mybatis.RoleMapper">
    <resultMap id="roleMapper" type="role">
        <result property="id" column="id"/>
        <result property="roleName" column="role_name" jdbcType="VARCHAR" javaType="string"/>
        <result property="note" column="note" typeHandler="mybatis.MyTypeHandler"/>
    </resultMap>

    <sql id="roleCols">
        id, role_name, note
    </sql>

    <insert id="insertRole" parameterType="role">
        <selectKey keyProperty="id" resultType="long" order="BEFORE">
            select if (max(id) = null, 1, max(id) + 3) from t_role
        </selectKey>
        insert into t_role(<include refid="roleCols">) values(#{id}, #{roleName}, #{note})
    </insert>

    <select id="getRole" parameterType="long" resultType="role">
        select <include refid="roleCols"> as roleName, note from t_role where id = #{id}
    </select>

</mapper>

sql元素还支持变量传递

<sql id="roleCols">
    ${alias}.id, ${alias}.role_name, ${alias}.note
</sql>

<select id="getRole" parameterType="long" resultMap="roleMap">
    select
    <include refid="roleCols">
        <property name="alias" value="r"/>
    </include>
    from t_role as r where where id = #{id}
</select>

参数

概述

一些数据库字段返回为null，而MyBatis系统又检测不到使用何种jdbcType进行处理时，会发生异常的情况，这个时候执行对应的typeHandler进行处理，MyBatis就指导采取哪个typeHandler进行处理了。

1	insert into t_role(id, role_name, note) values(#{id}, #{roleName, typeHandler=org.apache.ibatis.type.StringTypeHandler}, #{note})

而事实上，大部分情况下都不需要这样编写，因为MyBatis会根据javaType和jdbcType去检测使用哪个typeHandler。如果roleName是一个没有注册的类型，那么就会发生异常，因为MyBatis无法找到对应的typeHandler来转换数据类型。此时可以自定义TypeHandler，通过类似的办法指定，就不会抛出异常了。

在一些因为数据库返回null，存在可能抛出异常的情况下，也可以指定对应的jdbcType，从而让MyBatis能够探测到使用哪个typeHandler进行转换，以避免空指针异常。

1
2
3

#{age, javeType=int, jdbcType=NUMERIC, typeHandler=MyTypeHandler}

#{width, javaType=double, jdbcType=NUMERIC, numericScale=2}

存储过程参数支持

在MyBatis中提供了对存储过程的良好支持，对于简单的输出参数（比如INT,VARCHAR,DECIMAL）可以使用POJO通过映射来完成。

1
2
3

#{id, mode=IN}
#{roleName, mode=OUT}
#{note, mode=INOUT}

IN：输入参数是外接需要传递给存储过程的；
OUT：输出参数是存储过程经过处理后返回的；
INOUT：输入输出参数一方面外界需要可以传递给它，另一方面在最后存储过程也会将它返回给调用者。

特殊字符串的替换和处理（#和$）

类似于前面参数传递（$）和普通参数（#）的区别。

resultMap元素

resultMap元素构成

<resultMap id="" type="">
    <constructor>
        <idArg></idArg>
        <arg></arg>
    </constructor>
    <id></id>
    <result></result>
    <association property=""></association>
    <collection property=""></collection>
    <discriminator javaType="">
        <case value=""></case>
    </discriminator>
</resultMap>

其中constructor元素用于配置构造方法。
一个POJO可能不存在没有参数的构造方法，可以使用constructor进行配置。

假设角色类RoleBean不存在没有参数的构造方法，那么需要配置结果集：

1	public RoleBean(Integer id, String roleName);

<constructor>
    <idArg column="id" javaType="int"></idArg>
    <arg column="role_name" javeType="string"></arg>
</constructor>

如此，MyBatis就会使用对应的构造方法来构造POJO了
id元素表示哪个列是主键，允许多个主键，多个主键则成为联合主键。
result配置POJO到SQL列名的映射关系。

result元素和idArg元素的属性，如表所示：

元素名称	说明	备注
property	映射到列结果的字段或属性。如果POJO的属性匹配的是存在的且与给定SQL列名（column元素）相同的，那么MyBatis就会映射到POJO上	可以使用导航式的字段，比如访问一个学生对象（Student）需要访问学生证（selfcard）的发送日期（issueDate），那么可以写成selfcard.issueDate
column	对应的是SQL的列
javaType	配置Java的类型	可以是特定的类完全限定名或者MyBatis上下文的别名
jdbcType	配置数据库类型	这是一个JDBC的类型，MyBatis已经做了限定，支持大部分常用的数据库类型
typeHandler	类型处理器	允许用特定的处理器来覆盖MyBatis默认的处理器。这就要指定jdbcType和javaType相互转化的规则

例子：

<resultMap id="roleMapper" type="role">
    <result property="id" column="id"/>
    <result property="roleName" column="role_name" jdbcType="VARCHAR" javaType="string"/>
    <result property="note" column="note" typeHandler="mybatis.MyTypeHandler"/>
</resultMap>

使用map存储结果集（不推荐）

一般而言，任何select语句都可以使用map存储，使用map原则上是可以匹配所有结果集的，但是使用map接口意味着可读性的下降，因为使用map时需要进一步了解map键值的构成和数据类型，所以这不是一种推荐的方式，更多时候会推荐使用POJO方式

1
2
3

<select id="findColorByNote" parameterType="string" resultType="map">
    select id, color, note from t_color where note like concat('%', #{note}, '%')
</select>

使用POJO存储结果集（推荐）

1
2
3

<insert id="insertRole" parameterType="role">
    insert into t_role(role_name, note) values(#{roleName}, #{note})
</insert>

使用resultMap（推荐）

<resultMap id="roleMapper" type="role">
    <id property="id" column="id"/>
    <result property="roleName" column="role_name" jdbcType="VARCHAR" javaType="string"/>
    <result property="note" column="note" typeHandler="mybatis.MyTypeHandler"/>
</resultMap>
<select id="findRoles2" parameterType="string" resultMap="roleMapper">
    select id, role_name, note from t_role
    where note like concat('%', #{note, typeHandler=mybatis.MyTypeHandler}, '%')
</select>

resultMap属性id为这个resultMap的标识
type代表需要映射的POJO，这里可以使用MyBatis定义好的类的别名，也可以使用自定义的类的全限定名
元素id标识这个对象的主键
SQL语句的列名必须和roleMapper的column是一一对应的，使用XML配置的结果集，还可以配置typeHanlder、javaType、jdbcType等更多内容，但不能和resultType连用。

级联

级联是一个数据库实体的概念。级联不是必须的，级联的好处是获取关联数据十分便捷，但是级联过多会增加系统的复杂度，同时降低系统的性能，此增比减，所以当级联的层级超过3层时，就不要考虑使用级联了，因为这样会造成多个对象的关联，导致系统的耦合、复杂和难以维护。

此处略过，后面真得用得到在看来得及。

缓存

在MyBatis中允许使用缓存，缓存一般都放置在可高速读、写的存储器上，比如服务器的内存，它能够有效提高系统的性能。因为数据库在大部分场景下是把存储在磁盘上的数据索引出来。从硬件的角度分析，索引磁盘是一个较为缓慢的过程，读取内存或者高速缓存处理器的速度要比读取磁盘快得多，其速度是读取硬盘的几十倍到上百倍，但是内存和告诉缓存处理器的空间有限，所以一般只会把那些常用且命中率高的数据缓存起来，以便将来使用，而不缓存那些不常用且命中率低的数据缓存。

一级缓存和二级缓存

一级缓存是在SqlSession上的缓存，二级缓存是在SqlSessionFactory上的缓存。默认情况下，也就是没有任何配置的情况下，MyBatis系统会开启一级缓存，也就是对于SqlSession层面的缓存，这个缓存不需要POJO对象可序列化。

如果两次查询时完全相同的查询，且缓存没有超时就可以触发一级缓存：

传入的StatementId
查询时要求的结果集中的结果范围
这次查询所产生的最终要传递给JDBC java.sql.PreparedStatement的Sql语句字符串
传递给java.sqlStatement要设置的参数值

一级缓存触发

public static void main(String[] args) {
    Logger logger = Logger.getLogger(SqlSessionFactoryUtils.class);
    SqlSession sqlSession = null;
    try {
        sqlSession = SqlSessionFactoryUtils.openSqlSession();
        RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
        Role role = roleMapper.getRole(1L);
        logger.info(role.getRoleName());
        logger.info(role.getNote());
        logger.info("再获取一次POJO......");
        Role role1 = roleMapper.getRole(1L);
    } catch (Exception e){
        logger.info(e.getMessage(), e);
    }finally {
        if(sqlSession != null) sqlSession.close();
    }
}

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=65310:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-08 12:47:18,768 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-08 12:47:18,775 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 12:47:18,775 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 12:47:18,775 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 12:47:18,775 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 12:47:18,858 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-08 12:47:19,196 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 1758624236.
DEBUG 2021-09-08 12:47:19,196 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@68d279ec]
DEBUG 2021-09-08 12:47:19,198 mybatis.RoleMapper.getRole: ==>  Preparing: select id, role_name as roleName, note note from t_role where id = ?
DEBUG 2021-09-08 12:47:19,230 mybatis.RoleMapper.getRole: ==> Parameters: 1(Long)
DEBUG 2021-09-08 12:47:19,253 mybatis.RoleMapper.getRole: <==      Total: 1
 INFO 2021-09-08 12:47:19,254 mybatis.SqlSessionFactoryUtils: John
 INFO 2021-09-08 12:47:19,254 mybatis.SqlSessionFactoryUtils: Hello World!
 INFO 2021-09-08 12:47:19,254 mybatis.SqlSessionFactoryUtils: 再获取一次POJO......
DEBUG 2021-09-08 12:47:19,254 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@68d279ec]
DEBUG 2021-09-08 12:47:19,255 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@68d279ec]
DEBUG 2021-09-08 12:47:19,255 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 1758624236 to pool.

Process finished with exit code 0

一级缓存未触发

public static void main(String[] args) {
    Logger logger = Logger.getLogger(SqlSessionFactoryUtils.class);
    SqlSession sqlSession = null;
    try {
        sqlSession = SqlSessionFactoryUtils.openSqlSession();
        RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
        Role role = roleMapper.getRole(1L);
        logger.info(role.getRoleName());
        logger.info(role.getNote());
        logger.info("再获取一次POJO......");
        Role role1 = roleMapper.getRole(1L);
    } catch (Exception e){
        logger.info(e.getMessage(), e);
    }finally {
        if(sqlSession != null) sqlSession.close();
    }
}

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=61431:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-08 13:00:30,280 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-08 13:00:30,293 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:00:30,294 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:00:30,294 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:00:30,294 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:00:30,380 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-08 13:00:30,731 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 1676605578.
DEBUG 2021-09-08 13:00:30,731 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@63eef88a]
DEBUG 2021-09-08 13:00:30,734 mybatis.RoleMapper.getRole: ==>  Preparing: select id, role_name as roleName, note note from t_role where id = ?
DEBUG 2021-09-08 13:00:30,758 mybatis.RoleMapper.getRole: ==> Parameters: 1(Long)
DEBUG 2021-09-08 13:00:30,778 mybatis.RoleMapper.getRole: <==      Total: 1
 INFO 2021-09-08 13:00:30,779 mybatis.SqlSessionFactoryUtils: John
 INFO 2021-09-08 13:00:30,779 mybatis.SqlSessionFactoryUtils: Hello World!
 INFO 2021-09-08 13:00:30,779 mybatis.SqlSessionFactoryUtils: 再获取一次POJO......
DEBUG 2021-09-08 13:00:30,779 mybatis.RoleMapper.getRole: ==>  Preparing: select id, role_name as roleName, note note from t_role where id = ?
DEBUG 2021-09-08 13:00:30,780 mybatis.RoleMapper.getRole: ==> Parameters: 9(Long)
DEBUG 2021-09-08 13:00:30,781 mybatis.RoleMapper.getRole: <==      Total: 1
DEBUG 2021-09-08 13:00:30,781 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@63eef88a]
DEBUG 2021-09-08 13:00:30,781 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@63eef88a]
DEBUG 2021-09-08 13:00:30,781 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 1676605578 to pool.

Process finished with exit code 0

注意看第二次未触发一级缓存会多一个Preparing: sql语句

一级缓存作用范围

SQL被执行了两次，这说明一级缓存是在SqlSession层面的，对于不同的SQlSession对象时不能共享的。

public static void main(String[] args) {
    Logger logger = Logger.getLogger(SqlSessionFactoryUtils.class);
    SqlSession sqlSession = null;
    SqlSession sqlSession1 = null;
    try {
        sqlSession = SqlSessionFactoryUtils.openSqlSession();
        RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
        Role role = roleMapper.getRole(1L);
//            //System.out.println(JSON.toJSONString(role));
        logger.info(role.getRoleName());
        logger.info(role.getNote());
        sqlSession.commit(); //需要提交，如果是一级缓存，MyBatis才会缓存对象到SqlSessionFactory层面
        sqlSession1 = SqlSessionFactoryUtils.openSqlSession();
        RoleMapper roleMapper1 = sqlSession1.getMapper(RoleMapper.class);
        Role role1 = roleMapper1.getRole(1L);
        sqlSession1.commit();
    } catch (Exception e){
        logger.info(e.getMessage(), e);
    }finally {
        if(sqlSession != null) sqlSession.close();
    }
}

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=55295:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-08 13:09:00,794 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-08 13:09:00,810 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:09:00,810 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:09:00,811 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:09:00,811 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:09:00,915 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-08 13:09:01,252 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 1676605578.
DEBUG 2021-09-08 13:09:01,252 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@63eef88a]
DEBUG 2021-09-08 13:09:01,255 mybatis.RoleMapper.getRole: ==>  Preparing: select id, role_name as roleName, note note from t_role where id = ?
DEBUG 2021-09-08 13:09:01,283 mybatis.RoleMapper.getRole: ==> Parameters: 1(Long)
DEBUG 2021-09-08 13:09:01,306 mybatis.RoleMapper.getRole: <==      Total: 1
 INFO 2021-09-08 13:09:01,306 mybatis.SqlSessionFactoryUtils: John
 INFO 2021-09-08 13:09:01,307 mybatis.SqlSessionFactoryUtils: Hello World!
DEBUG 2021-09-08 13:09:01,307 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-08 13:09:01,344 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 147022238.
DEBUG 2021-09-08 13:09:01,344 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@8c3619e]
DEBUG 2021-09-08 13:09:01,345 mybatis.RoleMapper.getRole: ==>  Preparing: select id, role_name as roleName, note note from t_role where id = ?
DEBUG 2021-09-08 13:09:01,345 mybatis.RoleMapper.getRole: ==> Parameters: 1(Long)
DEBUG 2021-09-08 13:09:01,346 mybatis.RoleMapper.getRole: <==      Total: 1
DEBUG 2021-09-08 13:09:01,346 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@63eef88a]
DEBUG 2021-09-08 13:09:01,347 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@63eef88a]
DEBUG 2021-09-08 13:09:01,347 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 1676605578 to pool.

Process finished with exit code 0

开启二级缓存：

需要在RoleMapper.xml上加入代码：

<cache/>

需要序列化对象，否则会报错

1	public class Role implements Serializable {}

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=57888:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-08 13:17:38,121 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-08 13:17:38,134 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:17:38,134 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:17:38,134 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:17:38,134 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-08 13:17:38,221 mybatis.RoleMapper: Cache Hit Ratio [mybatis.RoleMapper]: 0.0
DEBUG 2021-09-08 13:17:38,225 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-08 13:17:38,561 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 35984028.
DEBUG 2021-09-08 13:17:38,561 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@225129c]
DEBUG 2021-09-08 13:17:38,564 mybatis.RoleMapper.getRole: ==>  Preparing: select id, role_name as roleName, note note from t_role where id = ?
DEBUG 2021-09-08 13:17:38,594 mybatis.RoleMapper.getRole: ==> Parameters: 1(Long)
DEBUG 2021-09-08 13:17:38,618 mybatis.RoleMapper.getRole: <==      Total: 1
 INFO 2021-09-08 13:17:38,618 mybatis.SqlSessionFactoryUtils: John
 INFO 2021-09-08 13:17:38,618 mybatis.SqlSessionFactoryUtils: Hello World!
 WARN 2021-09-08 13:17:38,624 org.apache.ibatis.io.SerialFilterChecker: As you are using functionality that deserializes object streams, it is recommended to define the JEP-290 serial filter. Please refer to https://docs.oracle.com/pls/topic/lookup?ctx=javase15&id=GUID-8296D8E8-2B93-4B9A-856E-0A65AF9B8C66
DEBUG 2021-09-08 13:17:38,626 mybatis.RoleMapper: Cache Hit Ratio [mybatis.RoleMapper]: 0.5
 INFO 2021-09-08 13:17:38,626 mybatis.SqlSessionFactoryUtils: John
DEBUG 2021-09-08 13:17:38,626 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@225129c]
DEBUG 2021-09-08 13:17:38,627 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@225129c]
DEBUG 2021-09-08 13:17:38,627 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 35984028 to pool.

Process finished with exit code 0

缓存配置项、自定义和应用

上一节只是配置了cache元素，加入了这个元素后，MyBatis就会将对应的命名空间内所有select元素SQL查询结果进行缓存，而其中的insert、delete和update语句在操作时会刷新缓存。

属性	说明	取值	备注
blocking	是否使用阻塞性缓存，在读/写时它会加入JNI的锁进行操作	true\|false，默认false	可保证读/写安全性，但加锁后性能不佳
readOnly	缓存内容是否只读	true\|false，默认false	如果为只读，则不会因为多个线程读/写造成不一致性
eviction	缓存策略：LRU/FIFO/SOFT/WEAK	默认值LRU
flushInterval	这是一个整数，它以毫秒为单位，比如1分钟刷新一次，则配置60000。默认,null，也就是没有刷新时间，只有当执行update时，insert和delete语句才会刷新	正整数	超时后缓存失效
type	自定义缓存类，要求实现org.apache.ibatis.cache.Cache	用于自定义缓存类
size	缓存对象个数	正整数，默认1024

自定义缓存实现类

可以自定义缓存，只需要实现接口org.apache.ibatis.cache.Cache

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.cache;

import java.util.concurrent.locks.ReadWriteLock;

public interface Cache {
    String getId();

    void putObject(Object var1, Object var2);

    Object getObject(Object var1);

    Object removeObject(Object var1);

    void clear();

    int getSize();

    default ReadWriteLock getReadWriteLock() {
        return null;
    }
}

其他缓存

现实中，可以使用Redis、MongoDB或者其他常用的缓存，可以如下配置：

1
2
3

<cache type="mybatis.RedisCache">
    <property name="host" value="localhost"/>
</cache>

这样配置后，MyBatis会启用缓存，同时调用setHost(String host)方法设置配置的内容：

语句自定义缓存

<select ... flushCache="false" userCache="true"/>
<insert ... flushCache="true"/>
<update ... flushCache="true"/>
<delete ... flushCache="true"/>

以上是默认配置，flushCache代表是否刷新缓存，userCache是select特有的，代表是否启用缓存。

缓存引用

一个映射器内配置，如RoleMapper.xml，那么其他映射器不能使用，如果其他映射器需要相同的配置，需要引用缓存配置：

1	<cache-ref namespace="mybatis.RoleMapper"/>

存储过程

输入参数
输出参数
输入输出参数

待跟进

动态SQL

概述

元素	作用	备注
if	判断语句	单条件分支判断
choose	相当于Java中的switch和case语句	多条件分支判断
trim(where, set)	辅助元素，用于处理特定的SQL拼装问题，比如去掉多余的and/or等
foreach	循环语句

if元素

<select id="findRoles" parameterType="string" resultMap="roleResultMap">
    select id, role_name, note from t_role where 1 = 1
    <if test="roleName != null and roleName != ''">
        and role_name like concat('%', #{roleName}, '%')
    </if>
</select>

choose、when、otherwise元素

类似于switch…case…default语句

<select id="findRoles" parameterType="role" resultMap="roleResultMap">
    select id, role_name, note from t_role
    where 1 = 1
    <choose>
        <when test="id != null and id !=''">
            and id = #{id}
        </when>
        <when test="roleName != null and roleName !=''">
            and role_name like concat('%', #{roleName}, '%')
        </when>
        <otherwise>
            and note is not null
        </otherwise>
    </choose>
</select>

trim、where、set元素

前面有$1 = 1$在where里，如果去掉，是一条错误语句，加上又很奇怪，可考虑一下写法去掉$1 = 1$
当where元素里的条件成立时，才会加入where这个SQL关键字

<select id="findRoles" parameterType="role" resultMap="roleResultMap">
    select id, role_name, note from t_role
    <where>
        <if test="roleName != null and roleName != ''">
            role_name like concat('%', #{roleName}, '%')
        </if>
        <if test="note != null and note !=''">
            and note like concat('%', #{note}, '%')
        </if>
    </where>
</select>

与上面等价

<select id="findRoles" parameterType="string" resultMap="roleResultMap">
    select id, role_name, note from t_role
    <trim prefix="where" prefixOverrides="and">
        <if test="roleName != null and roleName != ''">
            and role_name like concat('%', #{roleName}, '%')
        </if>
    </trim>
</select>

现实中，可能更新某一对象的某些字段，而非全部，可以使用set元素避免缺失问题：

<update id="updateRole" parameterType="role">
    update t_role
    <set>
        <if test="roleName != null and roleName != ''">
            role_name = #{roleName},
        </if>
        <if test="note != null and note !=''">
            note = #{note}
        </if>
    </set>
    where id = #{id}
</update>

set元素遇到逗号，会把对应的逗号去掉。

foreach元素

foreach元素是一个循环语句，用于遍历集合，能很好地支持数组和List、Set接口的集合。

<select id="findUserBySex" resultType="user">
    select * from t_role where id in
    <foreach item="roleNo" index="index" collection="roleNoList"
             open="(" separator="," close=")">
        #{roleNo}
    </foreach>
</select>

collection配置的roleNoList是传递进来的参数名称，它可以是一个数组、List、Set等集合；
item配置的是循环中当前的元素；
index配置的是当前元素在集合的位置下标；
open和close配置的是以什么符号将这些集合元素包装起来；
separator是各个元素的间隔符

用test的属性判断字符串

test用于条件判断语句，它在MyBatis中使用广泛。test的作用相当于判断真假，在大部分场景中，它都是用以判断空和非空的。

<select id="getRoleTest" parameterType="string" resultMap="roleResultMap">
      selct id, role_name, note from t_role
      <if test=" type == 'Y'.toString()">
          where 1=1
      </if>
</select>

bind元素

bind元素的作用通过OGNL表达式去定义一个上下文变量，更方便使用。

<select id="findRole" parameterType="string" resultType="role">
    <bind name="pattern" value="'%' + _parameter + '%"/>
    select id, role_name as roleName, create_date as createDate, end_date as endDate,
            end_flag as endFlag, note from t_role
    where role_name like #{pattern}
</select>

MyBatis的解析和运行原理

构建SqlSessionFactory过程

SqlSessionFactory是MyBatis的核心类之一，其最重要的功能就是提供创建MyBatis的核心接口SqlSession，所以要先创建SqlSessionFactory，为此要提供配置文件和相关的参数。

MyBatis是一个复杂的系统，它采用Builder模式去创建SqlSessionFactory，在实际中可以通过SqlSessionFactoryBuilder去构建：

第一步：通过org.apache.ibatis.builder.xml.XMLConfigBuilder解析配置的XML文件，独处所配置的参数，并将读取的内容存入org.apache.ibatis.Configuration类对象中。而Configuraion采用的是单例模式，几乎所有的MyBatis配置内容都会存放在这个单例对象中，以便后续将这些内容独处。
第二步：使用Configuration对象去创建SqlSessionFactory。SqlSessionFactory是一个接口，而不是一个实现类，为此MyBatis提供了一个默认的实现类org.apache.ibatis.session.defaults.DefaultSqlSessionFactory。

XMLConfigBuilder

从该方法可以看到，其通过一步步解析XML的内容得到对应的信息，而这些信息正式我们在配置文件中配置的内容。

private void parseConfiguration(XNode root) {
    try {
        this.propertiesElement(root.evalNode("properties"));
        Properties settings = this.settingsAsProperties(root.evalNode("settings"));
        this.loadCustomVfs(settings);
        this.loadCustomLogImpl(settings);
        this.typeAliasesElement(root.evalNode("typeAliases"));
        this.pluginElement(root.evalNode("plugins"));
        this.objectFactoryElement(root.evalNode("objectFactory"));
        this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        this.reflectorFactoryElement(root.evalNode("reflectorFactory"));
        this.settingsElement(settings);
        this.environmentsElement(root.evalNode("environments"));
        this.databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        this.typeHandlerElement(root.evalNode("typeHandlers"));
        this.mapperElement(root.evalNode("mappers"));
    } catch (Exception var3) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3);
    }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.builder.xml;

import java.io.InputStream;
import java.io.Reader;
import java.util.Iterator;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.ibatis.builder.BaseBuilder;
import org.apache.ibatis.builder.BuilderException;
import org.apache.ibatis.datasource.DataSourceFactory;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.executor.loader.ProxyFactory;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.io.VFS;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.mapping.DatabaseIdProvider;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.mapping.Environment.Builder;
import org.apache.ibatis.parsing.XNode;
import org.apache.ibatis.parsing.XPathParser;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.reflection.DefaultReflectorFactory;
import org.apache.ibatis.reflection.MetaClass;
import org.apache.ibatis.reflection.ReflectorFactory;
import org.apache.ibatis.reflection.factory.ObjectFactory;
import org.apache.ibatis.reflection.wrapper.ObjectWrapperFactory;
import org.apache.ibatis.session.AutoMappingBehavior;
import org.apache.ibatis.session.AutoMappingUnknownColumnBehavior;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.LocalCacheScope;
import org.apache.ibatis.transaction.TransactionFactory;
import org.apache.ibatis.type.JdbcType;

public class XMLConfigBuilder extends BaseBuilder {
    private boolean parsed;
    private final XPathParser parser;
    private String environment;
    private final ReflectorFactory localReflectorFactory;

    public XMLConfigBuilder(Reader reader) {
        this((Reader)reader, (String)null, (Properties)null);
    }

    public XMLConfigBuilder(Reader reader, String environment) {
        this((Reader)reader, environment, (Properties)null);
    }

    public XMLConfigBuilder(Reader reader, String environment, Properties props) {
        this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);
    }

    public XMLConfigBuilder(InputStream inputStream) {
        this((InputStream)inputStream, (String)null, (Properties)null);
    }

    public XMLConfigBuilder(InputStream inputStream, String environment) {
        this((InputStream)inputStream, environment, (Properties)null);
    }

    public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
        this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
    }

    private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
        super(new Configuration());
        this.localReflectorFactory = new DefaultReflectorFactory();
        ErrorContext.instance().resource("SQL Mapper Configuration");
        this.configuration.setVariables(props);
        this.parsed = false;
        this.environment = environment;
        this.parser = parser;
    }

    public Configuration parse() {
        if (this.parsed) {
            throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        } else {
            this.parsed = true;
            this.parseConfiguration(this.parser.evalNode("/configuration"));
            return this.configuration;
        }
    }

    private void parseConfiguration(XNode root) {
        try {
            this.propertiesElement(root.evalNode("properties"));
            Properties settings = this.settingsAsProperties(root.evalNode("settings"));
            this.loadCustomVfs(settings);
            this.loadCustomLogImpl(settings);
            this.typeAliasesElement(root.evalNode("typeAliases"));
            this.pluginElement(root.evalNode("plugins"));
            this.objectFactoryElement(root.evalNode("objectFactory"));
            this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            this.reflectorFactoryElement(root.evalNode("reflectorFactory"));
            this.settingsElement(settings);
            this.environmentsElement(root.evalNode("environments"));
            this.databaseIdProviderElement(root.evalNode("databaseIdProvider"));
            this.typeHandlerElement(root.evalNode("typeHandlers"));
            this.mapperElement(root.evalNode("mappers"));
        } catch (Exception var3) {
            throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3);
        }
    }

    private Properties settingsAsProperties(XNode context) {
        if (context == null) {
            return new Properties();
        } else {
            Properties props = context.getChildrenAsProperties();
            MetaClass metaConfig = MetaClass.forClass(Configuration.class, this.localReflectorFactory);
            Iterator var4 = props.keySet().iterator();

            Object key;
            do {
                if (!var4.hasNext()) {
                    return props;
                }

                key = var4.next();
            } while(metaConfig.hasSetter(String.valueOf(key)));

            throw new BuilderException("The setting " + key + " is not known.  Make sure you spelled it correctly (case sensitive).");
        }
    }

    private void loadCustomVfs(Properties props) throws ClassNotFoundException {
        String value = props.getProperty("vfsImpl");
        if (value != null) {
            String[] clazzes = value.split(",");
            String[] var4 = clazzes;
            int var5 = clazzes.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                String clazz = var4[var6];
                if (!clazz.isEmpty()) {
                    Class<? extends VFS> vfsImpl = Resources.classForName(clazz);
                    this.configuration.setVfsImpl(vfsImpl);
                }
            }
        }

    }

    private void loadCustomLogImpl(Properties props) {
        Class<? extends Log> logImpl = this.resolveClass(props.getProperty("logImpl"));
        this.configuration.setLogImpl(logImpl);
    }

    private void typeAliasesElement(XNode parent) {
        if (parent != null) {
            Iterator var2 = parent.getChildren().iterator();

            while(var2.hasNext()) {
                XNode child = (XNode)var2.next();
                String alias;
                if ("package".equals(child.getName())) {
                    alias = child.getStringAttribute("name");
                    this.configuration.getTypeAliasRegistry().registerAliases(alias);
                } else {
                    alias = child.getStringAttribute("alias");
                    String type = child.getStringAttribute("type");

                    try {
                        Class<?> clazz = Resources.classForName(type);
                        if (alias == null) {
                            this.typeAliasRegistry.registerAlias(clazz);
                        } else {
                            this.typeAliasRegistry.registerAlias(alias, clazz);
                        }
                    } catch (ClassNotFoundException var7) {
                        throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + var7, var7);
                    }
                }
            }
        }

    }

    private void pluginElement(XNode parent) throws Exception {
        if (parent != null) {
            Iterator var2 = parent.getChildren().iterator();

            while(var2.hasNext()) {
                XNode child = (XNode)var2.next();
                String interceptor = child.getStringAttribute("interceptor");
                Properties properties = child.getChildrenAsProperties();
                Interceptor interceptorInstance = (Interceptor)this.resolveClass(interceptor).getDeclaredConstructor().newInstance();
                interceptorInstance.setProperties(properties);
                this.configuration.addInterceptor(interceptorInstance);
            }
        }

    }

    private void objectFactoryElement(XNode context) throws Exception {
        if (context != null) {
            String type = context.getStringAttribute("type");
            Properties properties = context.getChildrenAsProperties();
            ObjectFactory factory = (ObjectFactory)this.resolveClass(type).getDeclaredConstructor().newInstance();
            factory.setProperties(properties);
            this.configuration.setObjectFactory(factory);
        }

    }

    private void objectWrapperFactoryElement(XNode context) throws Exception {
        if (context != null) {
            String type = context.getStringAttribute("type");
            ObjectWrapperFactory factory = (ObjectWrapperFactory)this.resolveClass(type).getDeclaredConstructor().newInstance();
            this.configuration.setObjectWrapperFactory(factory);
        }

    }

    private void reflectorFactoryElement(XNode context) throws Exception {
        if (context != null) {
            String type = context.getStringAttribute("type");
            ReflectorFactory factory = (ReflectorFactory)this.resolveClass(type).getDeclaredConstructor().newInstance();
            this.configuration.setReflectorFactory(factory);
        }

    }

    private void propertiesElement(XNode context) throws Exception {
        if (context != null) {
            Properties defaults = context.getChildrenAsProperties();
            String resource = context.getStringAttribute("resource");
            String url = context.getStringAttribute("url");
            if (resource != null && url != null) {
                throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
            }

            if (resource != null) {
                defaults.putAll(Resources.getResourceAsProperties(resource));
            } else if (url != null) {
                defaults.putAll(Resources.getUrlAsProperties(url));
            }

            Properties vars = this.configuration.getVariables();
            if (vars != null) {
                defaults.putAll(vars);
            }

            this.parser.setVariables(defaults);
            this.configuration.setVariables(defaults);
        }

    }

    private void settingsElement(Properties props) {
        this.configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
        this.configuration.setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior.valueOf(props.getProperty("autoMappingUnknownColumnBehavior", "NONE")));
        this.configuration.setCacheEnabled(this.booleanValueOf(props.getProperty("cacheEnabled"), true));
        this.configuration.setProxyFactory((ProxyFactory)this.createInstance(props.getProperty("proxyFactory")));
        this.configuration.setLazyLoadingEnabled(this.booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
        this.configuration.setAggressiveLazyLoading(this.booleanValueOf(props.getProperty("aggressiveLazyLoading"), false));
        this.configuration.setMultipleResultSetsEnabled(this.booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
        this.configuration.setUseColumnLabel(this.booleanValueOf(props.getProperty("useColumnLabel"), true));
        this.configuration.setUseGeneratedKeys(this.booleanValueOf(props.getProperty("useGeneratedKeys"), false));
        this.configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
        this.configuration.setDefaultStatementTimeout(this.integerValueOf(props.getProperty("defaultStatementTimeout"), (Integer)null));
        this.configuration.setDefaultFetchSize(this.integerValueOf(props.getProperty("defaultFetchSize"), (Integer)null));
        this.configuration.setDefaultResultSetType(this.resolveResultSetType(props.getProperty("defaultResultSetType")));
        this.configuration.setMapUnderscoreToCamelCase(this.booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
        this.configuration.setSafeRowBoundsEnabled(this.booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
        this.configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));
        this.configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
        this.configuration.setLazyLoadTriggerMethods(this.stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
        this.configuration.setSafeResultHandlerEnabled(this.booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
        this.configuration.setDefaultScriptingLanguage(this.resolveClass(props.getProperty("defaultScriptingLanguage")));
        this.configuration.setDefaultEnumTypeHandler(this.resolveClass(props.getProperty("defaultEnumTypeHandler")));
        this.configuration.setCallSettersOnNulls(this.booleanValueOf(props.getProperty("callSettersOnNulls"), false));
        this.configuration.setUseActualParamName(this.booleanValueOf(props.getProperty("useActualParamName"), true));
        this.configuration.setReturnInstanceForEmptyRow(this.booleanValueOf(props.getProperty("returnInstanceForEmptyRow"), false));
        this.configuration.setLogPrefix(props.getProperty("logPrefix"));
        this.configuration.setConfigurationFactory(this.resolveClass(props.getProperty("configurationFactory")));
        this.configuration.setShrinkWhitespacesInSql(this.booleanValueOf(props.getProperty("shrinkWhitespacesInSql"), false));
        this.configuration.setDefaultSqlProviderType(this.resolveClass(props.getProperty("defaultSqlProviderType")));
    }

    private void environmentsElement(XNode context) throws Exception {
        if (context != null) {
            if (this.environment == null) {
                this.environment = context.getStringAttribute("default");
            }

            Iterator var2 = context.getChildren().iterator();

            while(var2.hasNext()) {
                XNode child = (XNode)var2.next();
                String id = child.getStringAttribute("id");
                if (this.isSpecifiedEnvironment(id)) {
                    TransactionFactory txFactory = this.transactionManagerElement(child.evalNode("transactionManager"));
                    DataSourceFactory dsFactory = this.dataSourceElement(child.evalNode("dataSource"));
                    DataSource dataSource = dsFactory.getDataSource();
                    Builder environmentBuilder = (new Builder(id)).transactionFactory(txFactory).dataSource(dataSource);
                    this.configuration.setEnvironment(environmentBuilder.build());
                    break;
                }
            }
        }

    }

    private void databaseIdProviderElement(XNode context) throws Exception {
        DatabaseIdProvider databaseIdProvider = null;
        if (context != null) {
            String type = context.getStringAttribute("type");
            if ("VENDOR".equals(type)) {
                type = "DB_VENDOR";
            }

            Properties properties = context.getChildrenAsProperties();
            databaseIdProvider = (DatabaseIdProvider)this.resolveClass(type).getDeclaredConstructor().newInstance();
            databaseIdProvider.setProperties(properties);
        }

        Environment environment = this.configuration.getEnvironment();
        if (environment != null && databaseIdProvider != null) {
            String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
            this.configuration.setDatabaseId(databaseId);
        }

    }

    private TransactionFactory transactionManagerElement(XNode context) throws Exception {
        if (context != null) {
            String type = context.getStringAttribute("type");
            Properties props = context.getChildrenAsProperties();
            TransactionFactory factory = (TransactionFactory)this.resolveClass(type).getDeclaredConstructor().newInstance();
            factory.setProperties(props);
            return factory;
        } else {
            throw new BuilderException("Environment declaration requires a TransactionFactory.");
        }
    }

    private DataSourceFactory dataSourceElement(XNode context) throws Exception {
        if (context != null) {
            String type = context.getStringAttribute("type");
            Properties props = context.getChildrenAsProperties();
            DataSourceFactory factory = (DataSourceFactory)this.resolveClass(type).getDeclaredConstructor().newInstance();
            factory.setProperties(props);
            return factory;
        } else {
            throw new BuilderException("Environment declaration requires a DataSourceFactory.");
        }
    }

    private void typeHandlerElement(XNode parent) {
        if (parent != null) {
            Iterator var2 = parent.getChildren().iterator();

            while(var2.hasNext()) {
                XNode child = (XNode)var2.next();
                String typeHandlerPackage;
                if ("package".equals(child.getName())) {
                    typeHandlerPackage = child.getStringAttribute("name");
                    this.typeHandlerRegistry.register(typeHandlerPackage);
                } else {
                    typeHandlerPackage = child.getStringAttribute("javaType");
                    String jdbcTypeName = child.getStringAttribute("jdbcType");
                    String handlerTypeName = child.getStringAttribute("handler");
                    Class<?> javaTypeClass = this.resolveClass(typeHandlerPackage);
                    JdbcType jdbcType = this.resolveJdbcType(jdbcTypeName);
                    Class<?> typeHandlerClass = this.resolveClass(handlerTypeName);
                    if (javaTypeClass != null) {
                        if (jdbcType == null) {
                            this.typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
                        } else {
                            this.typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
                        }
                    } else {
                        this.typeHandlerRegistry.register(typeHandlerClass);
                    }
                }
            }
        }

    }

    private void mapperElement(XNode parent) throws Exception {
        if (parent != null) {
            Iterator var2 = parent.getChildren().iterator();

            while(true) {
                while(var2.hasNext()) {
                    XNode child = (XNode)var2.next();
                    String resource;
                    if ("package".equals(child.getName())) {
                        resource = child.getStringAttribute("name");
                        this.configuration.addMappers(resource);
                    } else {
                        resource = child.getStringAttribute("resource");
                        String url = child.getStringAttribute("url");
                        String mapperClass = child.getStringAttribute("class");
                        InputStream inputStream;
                        Throwable var8;
                        XMLMapperBuilder mapperParser;
                        if (resource != null && url == null && mapperClass == null) {
                            ErrorContext.instance().resource(resource);
                            inputStream = Resources.getResourceAsStream(resource);
                            var8 = null;

                            try {
                                mapperParser = new XMLMapperBuilder(inputStream, this.configuration, resource, this.configuration.getSqlFragments());
                                mapperParser.parse();
                            } catch (Throwable var32) {
                                var8 = var32;
                                throw var32;
                            } finally {
                                if (inputStream != null) {
                                    if (var8 != null) {
                                        try {
                                            inputStream.close();
                                        } catch (Throwable var30) {
                                            var8.addSuppressed(var30);
                                        }
                                    } else {
                                        inputStream.close();
                                    }
                                }

                            }
                        } else if (resource == null && url != null && mapperClass == null) {
                            ErrorContext.instance().resource(url);
                            inputStream = Resources.getUrlAsStream(url);
                            var8 = null;

                            try {
                                mapperParser = new XMLMapperBuilder(inputStream, this.configuration, url, this.configuration.getSqlFragments());
                                mapperParser.parse();
                            } catch (Throwable var31) {
                                var8 = var31;
                                throw var31;
                            } finally {
                                if (inputStream != null) {
                                    if (var8 != null) {
                                        try {
                                            inputStream.close();
                                        } catch (Throwable var29) {
                                            var8.addSuppressed(var29);
                                        }
                                    } else {
                                        inputStream.close();
                                    }
                                }

                            }
                        } else {
                            if (resource != null || url != null || mapperClass == null) {
                                throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
                            }

                            Class<?> mapperInterface = Resources.classForName(mapperClass);
                            this.configuration.addMapper(mapperInterface);
                        }
                    }
                }

                return;
            }
        }
    }

    private boolean isSpecifiedEnvironment(String id) {
        if (this.environment == null) {
            throw new BuilderException("No environment specified.");
        } else if (id == null) {
            throw new BuilderException("Environment requires an id attribute.");
        } else {
            return this.environment.equals(id);
        }
    }
}

构建Configuration

在SqlSessionFactory构建中，Configuration是最重要的，它的作用是：

读入配置文件，包括基础配置的XML和映射XML（或注解）；
初始化一些基础配置，比如MyBatis的别名等，一些重要的类对象（比如插件、映射器、Object工厂、typeHandler对象等）；
提供单例，为后续创建SessionFactory服务，提供配置的参数；
执行一些重要对象的初始化方法；

Configuration不会是一个很简单的类，MyBatis的配置信息都来自于此，其通过XMLConfigBuilder去构建的，首先它会读出所有XML配置的信息，然后把它们解析并保存在Configuration单例中。并初始化以下内容：

properties全局参数
typeAliases别名
Plugins插件
objectFactory对象工厂
objectWrapperFactory对象包装工厂
reflectionFactory反射工厂
settings环境设置
environments数据库环境
databaseIdProvider数据库标识
typeHandlers类型转换器
Mappers映射器

它们都会以类似typeHandler注册那样的方法被存放到Configuration单例中。

构建映射器的内部组成

当XMLConfigBuilder解析XML时，会将每一个SQL和其配置的内容保存起来，一般而言，在MyBatis中一条SQL和它相关的配置信息是由3个部分组成的，它们分别是MappedStatement、SqlSource和BoundSql。

MappedStatement的作用是保存一个映射器节点(select/insert/delete/update)的内容。它是一个类，包括许多我们配置的SQL、SQL的id、缓存信息、resultMap、parameterType、resultType等重要配置内容。他还有一个重要的属性sqlSourec。MyBatis通过读取它来获得某条SQL配置的所有信息。
SqlSource是提供BoundSql对象的地方，它是MappedStatement的一个属性。它是一个接口，它有几个实现类DynamicSqlSource、ProviderSqlSource、RawSqlSource、StatisSqlSource。它的作用是根据上下文和参数解析生成需要的SQL、这个接口只定义了一个接口方法——getBoundSql(parameterObject)，使用它就可以得到一个BoundSql对象。
BoundSql是一个结果对象，也就是SqlSource通过对SQL和参数的联合解析得到的SQL和参数，它是建立SQL和参数的地方，它有3个常用的属性：sql、parameterObject、parameterMappings。

BoundSql会提供3个主要的属性：parameterMappings、parameterObject和sql。
（1）parameterObject为参数本身，可以传递简单对象、POJO或者Map、@Param注解的参数：

传递简单对象，包括int、String、float、double等。当传递基本数据类型时会装箱；
传递POJO或者Map，parameterObject就是传入的POJO或Map
传递多个参数，如果没有@Param注解，那么MyBatis就会把parameterObject变为一个Map<String, Object>对象，其键值的关系是按顺序来规划的，类似于{“1”:p1, “2”:p2…}，所以在编写时可以使用#{param1}或者#{1}去应用第一个参数
使用@Param注解，MyBatis会把parameterObject也变成一个Map<String,Object>对象，类似于没有@Param对象，只是把其数字的键值替换成@Param注解的键值。{“key1”:p1, “key2”:p2,”roleName”:p3}
（2）parameterMappings是一个List，它的每一个元素都是ParameterMapping对象。对象绘描述参数，参数包括属性名称、表达式、javaType、jdbcType、typeHanlder等重要信息，一般不需要去改变它。通过它就可以实现参数和SQL的结合，以便PreparedStatement能够通过它找到parameterObject对象的属性设置参数。
（3）sql属性就是书写在映射器里面的一条被SqlSource解析后的SQL。在大部分时候无须修改它，只是在使用插件时可以根据需要进行改写。

构建SqlSessionFactory

通过文件流生成Configuration对象，进而构建SqlSessionFactory对象

public static SqlSessionFactory getSqlSessionFactory(){
      synchronized (LOCK){
          if(sqlSessionFactory != null) return sqlSessionFactory;
          String resource = "mybatis\\mybatis-config.xml";
          InputStream inputStream;
          try{
              inputStream = Resources.getResourceAsStream(resource);
              sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
          }catch (IOException e){
              e.printStackTrace();
              return null;
          }
          return sqlSessionFactory;
      }
}

SqlSession运行过程

映射器（Mapper）的动态代理

1	RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);

DefaultSqlSession

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.session.defaults;

import org.apache.ibatis.session.SqlSession;

public class DefaultSqlSession implements SqlSession {
    private final Configuration configuration;
    private final Executor executor;
    private final boolean autoCommit;
    private boolean dirty;
    private List<Cursor<?>> cursorList;

    public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
        this.configuration = configuration;
        this.executor = executor;
        this.dirty = false;
        this.autoCommit = autoCommit;
    }

    public DefaultSqlSession(Configuration configuration, Executor executor) {
        this(configuration, executor, false);
    }

    //通过Configuration对象的getMapper方法
    public <T> T getMapper(Class<T> type) {
        return this.configuration.getMapper(type, this);
    }
}

Configuration

追踪得到其通过MapperRegistry来获取对应的接口对象。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.session;

public class Configuration {

    protected final MapperRegistry mapperRegistry;

    public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        return this.mapperRegistry.getMapper(type, sqlSession);
    }

}

MapperRegistry

先判断是否需要注册一个Mapper，如果没有则会抛出异常信息，否则就会启用MapperProxyFactory工厂来生成一个代理实例。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.binding;


public class MapperRegistry {
    private final Configuration config;
    private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap();

    public MapperRegistry(Configuration config) {
        this.config = config;
    }

    public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);
        if (mapperProxyFactory == null) {
            throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
        } else {
            try {
                return mapperProxyFactory.newInstance(sqlSession);
            } catch (Exception var5) {
                throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);
            }
        }
    }
}

MapperProxyFactory

这里Mapper映射时通过动态代理来实现的。这里可以看到动态代理对接口的绑定，它的作用就是生成动态代理对象（占位），而代理的方法则被放到了MapperProxy类中。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.binding;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.ibatis.binding.MapperProxy.MapperMethodInvoker;
import org.apache.ibatis.session.SqlSession;

public class MapperProxyFactory<T> {
    private final Class<T> mapperInterface;
    private final Map<Method, MapperMethodInvoker> methodCache = new ConcurrentHashMap();

    public MapperProxyFactory(Class<T> mapperInterface) {
        this.mapperInterface = mapperInterface;
    }

    public Class<T> getMapperInterface() {
        return this.mapperInterface;
    }

    public Map<Method, MapperMethodInvoker> getMethodCache() {
        return this.methodCache;
    }

    protected T newInstance(MapperProxy<T> mapperProxy) {
        return Proxy.newProxyInstance(this.mapperInterface.getClassLoader(), new Class[]{this.mapperInterface}, mapperProxy);
    }

    public T newInstance(SqlSession sqlSession) {
        MapperProxy<T> mapperProxy = new MapperProxy(sqlSession, this.mapperInterface, this.methodCache);
        return this.newInstance(mapperProxy);
    }
}

MapperProxy

可以看到这里的invoke方法逻辑，如果Mapper是一个JDK动态代理对象，那么就会运行到invoke方法里面。
invoke首先判断是否是一个类，这里Mapper是一个接口不是类，所以判定失败。然后会生成MapperMethod对象，它是通过cachedMapperMethod方法对其初始化的。最后执行execute方法，把SqlSession和当前运行的参数传递进去。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.binding;

import java.io.Serializable;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import org.apache.ibatis.reflection.ExceptionUtil;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.util.MapUtil;

public class MapperProxy<T> implements InvocationHandler, Serializable {
    private static final long serialVersionUID = -4724728412955527868L;
    private static final int ALLOWED_MODES = 15;
    private static final Constructor<Lookup> lookupConstructor;
    private static final Method privateLookupInMethod;
    private final SqlSession sqlSession;
    private final Class<T> mapperInterface;
    private final Map<Method, MapperProxy.MapperMethodInvoker> methodCache;

    public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperProxy.MapperMethodInvoker> methodCache) {
        this.sqlSession = sqlSession;
        this.mapperInterface = mapperInterface;
        this.methodCache = methodCache;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            return Object.class.equals(method.getDeclaringClass()) ? method.invoke(this, args) : this.cachedInvoker(method).invoke(proxy, method, args, this.sqlSession);
        } catch (Throwable var5) {
            throw ExceptionUtil.unwrapThrowable(var5);
        }
    }

    private MapperProxy.MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
        try {
            return (MapperProxy.MapperMethodInvoker)MapUtil.computeIfAbsent(this.methodCache, method, (m) -> {
                if (m.isDefault()) {
                    try {
                        return privateLookupInMethod == null ? new MapperProxy.DefaultMethodInvoker(this.getMethodHandleJava8(method)) : new MapperProxy.DefaultMethodInvoker(this.getMethodHandleJava9(method));
                    } catch (InstantiationException | InvocationTargetException | NoSuchMethodException | IllegalAccessException var4) {
                        throw new RuntimeException(var4);
                    }
                } else {
                    return new MapperProxy.PlainMethodInvoker(new MapperMethod(this.mapperInterface, method, this.sqlSession.getConfiguration()));
                }
            });
        } catch (RuntimeException var4) {
            Throwable cause = var4.getCause();
            throw (Throwable)(cause == null ? var4 : cause);
        }
    }

    private MethodHandle getMethodHandleJava9(Method method) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        Class<?> declaringClass = method.getDeclaringClass();
        return ((Lookup)privateLookupInMethod.invoke((Object)null, declaringClass, MethodHandles.lookup())).findSpecial(declaringClass, method.getName(), MethodType.methodType(method.getReturnType(), method.getParameterTypes()), declaringClass);
    }

    private MethodHandle getMethodHandleJava8(Method method) throws IllegalAccessException, InstantiationException, InvocationTargetException {
        Class<?> declaringClass = method.getDeclaringClass();
        return ((Lookup)lookupConstructor.newInstance(declaringClass, 15)).unreflectSpecial(method, declaringClass);
    }

    static {
        Method privateLookupIn;
        try {
            privateLookupIn = MethodHandles.class.getMethod("privateLookupIn", Class.class, Lookup.class);
        } catch (NoSuchMethodException var5) {
            privateLookupIn = null;
        }

        privateLookupInMethod = privateLookupIn;
        Constructor<Lookup> lookup = null;
        if (privateLookupInMethod == null) {
            try {
                lookup = Lookup.class.getDeclaredConstructor(Class.class, Integer.TYPE);
                lookup.setAccessible(true);
            } catch (NoSuchMethodException var3) {
                throw new IllegalStateException("There is neither 'privateLookupIn(Class, Lookup)' nor 'Lookup(Class, int)' method in java.lang.invoke.MethodHandles.", var3);
            } catch (Exception var4) {
                lookup = null;
            }
        }

        lookupConstructor = lookup;
    }

    private static class DefaultMethodInvoker implements MapperProxy.MapperMethodInvoker {
        private final MethodHandle methodHandle;

        public DefaultMethodInvoker(MethodHandle methodHandle) {
            this.methodHandle = methodHandle;
        }

        public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
            return this.methodHandle.bindTo(proxy).invokeWithArguments(args);
        }
    }

    private static class PlainMethodInvoker implements MapperProxy.MapperMethodInvoker {
        private final MapperMethod mapperMethod;

        public PlainMethodInvoker(MapperMethod mapperMethod) {
            this.mapperMethod = mapperMethod;
        }

        public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
            return this.mapperMethod.execute(sqlSession, args);
        }
    }

    interface MapperMethodInvoker {
        Object invoke(Object var1, Method var2, Object[] var3, SqlSession var4) throws Throwable;
    }
}

MapperMethod

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.binding;

import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.apache.ibatis.annotations.Flush;
import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ResultMap;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.mapping.StatementType;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.ParamNameResolver;
import org.apache.ibatis.reflection.TypeParameterResolver;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;

public class MapperMethod {
    private final MapperMethod.SqlCommand command;
    private final MapperMethod.MethodSignature method;

    public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
        this.command = new MapperMethod.SqlCommand(config, mapperInterface, method);
        this.method = new MapperMethod.MethodSignature(config, mapperInterface, method);
    }

    public Object execute(SqlSession sqlSession, Object[] args) {
        Object result;
        Object param;
        switch(this.command.getType()) {
        case INSERT:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.insert(this.command.getName(), param));
            break;
        case UPDATE:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.update(this.command.getName(), param));
            break;
        case DELETE:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.delete(this.command.getName(), param));
            break;
        case SELECT:
            if (this.method.returnsVoid() && this.method.hasResultHandler()) {
                this.executeWithResultHandler(sqlSession, args);
                result = null;
            } else if (this.method.returnsMany()) {
                result = this.executeForMany(sqlSession, args);
            } else if (this.method.returnsMap()) {
                result = this.executeForMap(sqlSession, args);
            } else if (this.method.returnsCursor()) {
                result = this.executeForCursor(sqlSession, args);
            } else {
                param = this.method.convertArgsToSqlCommandParam(args);
                result = sqlSession.selectOne(this.command.getName(), param);
                if (this.method.returnsOptional() && (result == null || !this.method.getReturnType().equals(result.getClass()))) {
                    result = Optional.ofNullable(result);
                }
            }
            break;
        case FLUSH:
            result = sqlSession.flushStatements();
            break;
        default:
            throw new BindingException("Unknown execution method for: " + this.command.getName());
        }

        if (result == null && this.method.getReturnType().isPrimitive() && !this.method.returnsVoid()) {
            throw new BindingException("Mapper method '" + this.command.getName() + " attempted to return null from a method with a primitive return type (" + this.method.getReturnType() + ").");
        } else {
            return result;
        }
    }

    private Object rowCountResult(int rowCount) {
        Object result;
        if (this.method.returnsVoid()) {
            result = null;
        } else if (!Integer.class.equals(this.method.getReturnType()) && !Integer.TYPE.equals(this.method.getReturnType())) {
            if (!Long.class.equals(this.method.getReturnType()) && !Long.TYPE.equals(this.method.getReturnType())) {
                if (!Boolean.class.equals(this.method.getReturnType()) && !Boolean.TYPE.equals(this.method.getReturnType())) {
                    throw new BindingException("Mapper method '" + this.command.getName() + "' has an unsupported return type: " + this.method.getReturnType());
                }

                result = rowCount > 0;
            } else {
                result = (long)rowCount;
            }
        } else {
            result = rowCount;
        }

        return result;
    }

    private void executeWithResultHandler(SqlSession sqlSession, Object[] args) {
        MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(this.command.getName());
        if (!StatementType.CALLABLE.equals(ms.getStatementType()) && Void.TYPE.equals(((ResultMap)ms.getResultMaps().get(0)).getType())) {
            throw new BindingException("method " + this.command.getName() + " needs either a @ResultMap annotation, a @ResultType annotation, or a resultType attribute in XML so a ResultHandler can be used as a parameter.");
        } else {
            Object param = this.method.convertArgsToSqlCommandParam(args);
            if (this.method.hasRowBounds()) {
                RowBounds rowBounds = this.method.extractRowBounds(args);
                sqlSession.select(this.command.getName(), param, rowBounds, this.method.extractResultHandler(args));
            } else {
                sqlSession.select(this.command.getName(), param, this.method.extractResultHandler(args));
            }

        }
    }

    private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
        Object param = this.method.convertArgsToSqlCommandParam(args);
        List result;
        if (this.method.hasRowBounds()) {
            RowBounds rowBounds = this.method.extractRowBounds(args);
            result = sqlSession.selectList(this.command.getName(), param, rowBounds);
        } else {
            result = sqlSession.selectList(this.command.getName(), param);
        }

        if (!this.method.getReturnType().isAssignableFrom(result.getClass())) {
            return this.method.getReturnType().isArray() ? this.convertToArray(result) : this.convertToDeclaredCollection(sqlSession.getConfiguration(), result);
        } else {
            return result;
        }
    }

    private <T> Cursor<T> executeForCursor(SqlSession sqlSession, Object[] args) {
        Object param = this.method.convertArgsToSqlCommandParam(args);
        Cursor result;
        if (this.method.hasRowBounds()) {
            RowBounds rowBounds = this.method.extractRowBounds(args);
            result = sqlSession.selectCursor(this.command.getName(), param, rowBounds);
        } else {
            result = sqlSession.selectCursor(this.command.getName(), param);
        }

        return result;
    }

    private <E> Object convertToDeclaredCollection(Configuration config, List<E> list) {
        Object collection = config.getObjectFactory().create(this.method.getReturnType());
        MetaObject metaObject = config.newMetaObject(collection);
        metaObject.addAll(list);
        return collection;
    }

    private <E> Object convertToArray(List<E> list) {
        Class<?> arrayComponentType = this.method.getReturnType().getComponentType();
        Object array = Array.newInstance(arrayComponentType, list.size());
        if (!arrayComponentType.isPrimitive()) {
            return list.toArray((Object[])((Object[])array));
        } else {
            for(int i = 0; i < list.size(); ++i) {
                Array.set(array, i, list.get(i));
            }

            return array;
        }
    }

    private <K, V> Map<K, V> executeForMap(SqlSession sqlSession, Object[] args) {
        Object param = this.method.convertArgsToSqlCommandParam(args);
        Map result;
        if (this.method.hasRowBounds()) {
            RowBounds rowBounds = this.method.extractRowBounds(args);
            result = sqlSession.selectMap(this.command.getName(), param, this.method.getMapKey(), rowBounds);
        } else {
            result = sqlSession.selectMap(this.command.getName(), param, this.method.getMapKey());
        }

        return result;
    }

    public static class MethodSignature {
        private final boolean returnsMany;
        private final boolean returnsMap;
        private final boolean returnsVoid;
        private final boolean returnsCursor;
        private final boolean returnsOptional;
        private final Class<?> returnType;
        private final String mapKey;
        private final Integer resultHandlerIndex;
        private final Integer rowBoundsIndex;
        private final ParamNameResolver paramNameResolver;

        public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) {
            Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
            if (resolvedReturnType instanceof Class) {
                this.returnType = (Class)resolvedReturnType;
            } else if (resolvedReturnType instanceof ParameterizedType) {
                this.returnType = (Class)((ParameterizedType)resolvedReturnType).getRawType();
            } else {
                this.returnType = method.getReturnType();
            }

            this.returnsVoid = Void.TYPE.equals(this.returnType);
            this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();
            this.returnsCursor = Cursor.class.equals(this.returnType);
            this.returnsOptional = Optional.class.equals(this.returnType);
            this.mapKey = this.getMapKey(method);
            this.returnsMap = this.mapKey != null;
            this.rowBoundsIndex = this.getUniqueParamIndex(method, RowBounds.class);
            this.resultHandlerIndex = this.getUniqueParamIndex(method, ResultHandler.class);
            this.paramNameResolver = new ParamNameResolver(configuration, method);
        }

        public Object convertArgsToSqlCommandParam(Object[] args) {
            return this.paramNameResolver.getNamedParams(args);
        }

        public boolean hasRowBounds() {
            return this.rowBoundsIndex != null;
        }

        public RowBounds extractRowBounds(Object[] args) {
            return this.hasRowBounds() ? (RowBounds)args[this.rowBoundsIndex] : null;
        }

        public boolean hasResultHandler() {
            return this.resultHandlerIndex != null;
        }

        public ResultHandler extractResultHandler(Object[] args) {
            return this.hasResultHandler() ? (ResultHandler)args[this.resultHandlerIndex] : null;
        }

        public Class<?> getReturnType() {
            return this.returnType;
        }

        public boolean returnsMany() {
            return this.returnsMany;
        }

        public boolean returnsMap() {
            return this.returnsMap;
        }

        public boolean returnsVoid() {
            return this.returnsVoid;
        }

        public boolean returnsCursor() {
            return this.returnsCursor;
        }

        public boolean returnsOptional() {
            return this.returnsOptional;
        }

        private Integer getUniqueParamIndex(Method method, Class<?> paramType) {
            Integer index = null;
            Class<?>[] argTypes = method.getParameterTypes();

            for(int i = 0; i < argTypes.length; ++i) {
                if (paramType.isAssignableFrom(argTypes[i])) {
                    if (index != null) {
                        throw new BindingException(method.getName() + " cannot have multiple " + paramType.getSimpleName() + " parameters");
                    }

                    index = i;
                }
            }

            return index;
        }

        public String getMapKey() {
            return this.mapKey;
        }

        private String getMapKey(Method method) {
            String mapKey = null;
            if (Map.class.isAssignableFrom(method.getReturnType())) {
                MapKey mapKeyAnnotation = (MapKey)method.getAnnotation(MapKey.class);
                if (mapKeyAnnotation != null) {
                    mapKey = mapKeyAnnotation.value();
                }
            }

            return mapKey;
        }
    }

    public static class SqlCommand {
        private final String name;
        private final SqlCommandType type;

        public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
            String methodName = method.getName();
            Class<?> declaringClass = method.getDeclaringClass();
            MappedStatement ms = this.resolveMappedStatement(mapperInterface, methodName, declaringClass, configuration);
            if (ms == null) {
                if (method.getAnnotation(Flush.class) == null) {
                    throw new BindingException("Invalid bound statement (not found): " + mapperInterface.getName() + "." + methodName);
                }

                this.name = null;
                this.type = SqlCommandType.FLUSH;
            } else {
                this.name = ms.getId();
                this.type = ms.getSqlCommandType();
                if (this.type == SqlCommandType.UNKNOWN) {
                    throw new BindingException("Unknown execution method for: " + this.name);
                }
            }

        }

        public String getName() {
            return this.name;
        }

        public SqlCommandType getType() {
            return this.type;
        }

        private MappedStatement resolveMappedStatement(Class<?> mapperInterface, String methodName, Class<?> declaringClass, Configuration configuration) {
            String statementId = mapperInterface.getName() + "." + methodName;
            if (configuration.hasStatement(statementId)) {
                return configuration.getMappedStatement(statementId);
            } else if (mapperInterface.equals(declaringClass)) {
                return null;
            } else {
                Class[] var6 = mapperInterface.getInterfaces();
                int var7 = var6.length;

                for(int var8 = 0; var8 < var7; ++var8) {
                    Class<?> superInterface = var6[var8];
                    if (declaringClass.isAssignableFrom(superInterface)) {
                        MappedStatement ms = this.resolveMappedStatement(superInterface, methodName, declaringClass, configuration);
                        if (ms != null) {
                            return ms;
                        }
                    }
                }

                return null;
            }
        }
    }

    public static class ParamMap<V> extends HashMap<String, V> {
        private static final long serialVersionUID = -2212268410512043556L;

        public ParamMap() {
        }

        public V get(Object key) {
            if (!super.containsKey(key)) {
                throw new BindingException("Parameter '" + key + "' not found. Available parameters are " + this.keySet());
            } else {
                return super.get(key);
            }
        }
    }
}

SqlSession下的四大对象

映射器就是一个动态代理对进入到了MapperMethod的execute方法，然后它经过简单地判断进入了SqlSession的delete、update、insert、select等方法；

而这些方法是如何执行的呢？这是正确编写插件的根本。

SqlSession的执行过程是通过Executor、StatementHandler、ParameterHandler和ResultSetHandler来完成数据库操作和结果返回的。

Executor代表执行器，由它调度StatementHandler、ParameterHandler、ResultSetHandler等来执行对应的SQL。其中StatementHandler是最重要的。
StatementHandler的作用是使用数据库的Statement(PreparedStatement)执行操作，它是四大对象的核心，起到承上启下的作用，许多重要的插件都是通过拦截它来实现的。
ParameterHandler是用来处理SQL参数的。
ResultSetHandler是进行数据集（ResultSet）的封装返回处理的，它相当复杂，不过不常用。

Executor——执行器

MyBatis中有3种执行器，可以粽子配置文件中进行选择，即settings元素中的defaultExecutorType属性：

SIMPLE——简易执行器，不配置时就作为默认执行器
REUSE——它是一种能够执行重用预处理语句的执行器
BATCH——执行器重用语句和批量更新，批量专用的执行器

MyBatis通过Configuration类创建Executor

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? this.defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Object executor;
    if (ExecutorType.BATCH == executorType) {
        executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
        executor = new ReuseExecutor(this, transaction);
    } else {
        executor = new SimpleExecutor(this, transaction);
    }

    if (this.cacheEnabled) {
        executor = new CachingExecutor((Executor)executor);
    }

    Executor executor = (Executor)this.interceptorChain.pluginAll(executor);
    return executor;
}

以SimpleExcutor为例，通过Configuration来构建StatementHandler，然后使用prepareStatement方法，对SQL编译和参数进行初始化。其调用了StatementHandler进行预编译和基础设置，最后使用query方法，将ResultHandler传递进去

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.executor;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Collections;
import java.util.List;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.transaction.Transaction;

public class SimpleExecutor extends BaseExecutor {
    public SimpleExecutor(Configuration configuration, Transaction transaction) {
        super(configuration, transaction);
    }

    public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
        Statement stmt = null;

        int var6;
        try {
            Configuration configuration = ms.getConfiguration();
            StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, (ResultHandler)null, (BoundSql)null);
            stmt = this.prepareStatement(handler, ms.getStatementLog());
            var6 = handler.update(stmt);
        } finally {
            this.closeStatement(stmt);
        }

        return var6;
    }

    public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        Statement stmt = null;

        List var9;
        try {
            Configuration configuration = ms.getConfiguration();
            StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            stmt = this.prepareStatement(handler, ms.getStatementLog());
            var9 = handler.query(stmt, resultHandler);
        } finally {
            this.closeStatement(stmt);
        }

        return var9;
    }

    protected <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException {
        Configuration configuration = ms.getConfiguration();
        StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, parameter, rowBounds, (ResultHandler)null, boundSql);
        Statement stmt = this.prepareStatement(handler, ms.getStatementLog());
        Cursor<E> cursor = handler.queryCursor(stmt);
        stmt.closeOnCompletion();
        return cursor;
    }

    public List<BatchResult> doFlushStatements(boolean isRollback) {
        return Collections.emptyList();
    }

    private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
        Connection connection = this.getConnection(statementLog);
        Statement stmt = handler.prepare(connection, this.transaction.getTimeout());
        handler.parameterize(stmt);
        return stmt;
    }
}

StatementHandler——数据库会话器

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    StatementHandler statementHandler = (StatementHandler)this.interceptorChain.pluginAll(statementHandler);
    return statementHandler;
}

创建一个RoutingStatementHandler对象，其实现了接口StatementHandler，并根据上下文环境决定创建哪个具体的StatementHandler对象实例。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.executor.statement;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.ExecutorException;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;

public class RoutingStatementHandler implements StatementHandler {
    private final StatementHandler delegate;

    public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        switch(ms.getStatementType()) {
        case STATEMENT:
            this.delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
        case PREPARED:
            this.delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
        case CALLABLE:
            this.delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
        default:
            throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
        }

    }

    public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
        return this.delegate.prepare(connection, transactionTimeout);
    }

    public void parameterize(Statement statement) throws SQLException {
        this.delegate.parameterize(statement);
    }

    public void batch(Statement statement) throws SQLException {
        this.delegate.batch(statement);
    }

    public int update(Statement statement) throws SQLException {
        return this.delegate.update(statement);
    }

    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        return this.delegate.query(statement, resultHandler);
    }

    public <E> Cursor<E> queryCursor(Statement statement) throws SQLException {
        return this.delegate.queryCursor(statement);
    }

    public BoundSql getBoundSql() {
        return this.delegate.getBoundSql();
    }

    public ParameterHandler getParameterHandler() {
        return this.delegate.getParameterHandler();
    }
}

ParameterHandler——参数处理器

getParameterObject()方法的作用是返回参数对象

setParameters()方法的作用是设置预编译SQL语句的参数。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.executor.parameter;

import java.sql.PreparedStatement;
import java.sql.SQLException;

public interface ParameterHandler {
    Object getParameterObject();

    void setParameters(PreparedStatement var1) throws SQLException;
}

ResultSetHandler——结果处理器

handleOutputParameters()方法是处理存储过程输出参数的。

handleResultSets()是包装结果集的。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.executor.resultset;

import java.sql.CallableStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import org.apache.ibatis.cursor.Cursor;

public interface ResultSetHandler {
    <E> List<E> handleResultSets(Statement var1) throws SQLException;

    <E> Cursor<E> handleCursorResultSets(Statement var1) throws SQLException;

    void handleOutputParameters(CallableStatement var1) throws SQLException;
}

SqlSession运行总结

SqlSession是通过执行器Executor调度StatementHandler来运行的。
而StatementHandler经过3步：

prepared预编译SQL
parameterize设置参数
query/update执行SQL

其中parameterize是调用parameterHandler的方法设置的，而参数是根据类型处理器typeHandler处理的。query/update方法通过ResultSetHandler进行处理结果的封装，如果是update语句，就返回整数，否则就通过typeHandler处理结果类型，然后用ObjectFactory提供的规则组装对象，返回给调用者。

插件

插件接口

在MyBatis中使用插件，就必须实现接口Interceptor

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.plugin;

import java.util.Properties;

public interface Interceptor {
    Object intercept(Invocation var1) throws Throwable;

    default Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    default void setProperties(Properties properties) {
    }
}

intercept方法：它将直接覆盖拦截对象原有的方法，因此它是插件的核心方法。intercept里面有个参数Invocation对象，通过它可以反射调度原来对象的方法。
plugin方法：target是被拦截对象，它的作用是给被拦截对象生成一个代理对象，并返回它。在MyBatis中，它提供了org.apache.ibatis.plugin.Plugin中的wrap静态方法生成代理对象，一般情况下都会使用它来生成代理对象。
setProperties方法：允许在plugin元素汇总配置所需参数，方法在插件初始化时就被调用了一次，然后把插件对象存入到配置中，以便后面再取出。

插件的初始化

通过XMLConfigBuilder的代码可以发现，在解析配置文件时，在MyBatis的上下文初始化过程中，就开始读入插件节点和配置的参数，同时使用反射技术生成对应的插件实例，然后调用插件方法中的setProperties方法，设置我们配置的参数，将插件实例保存到配置对象中，以便读取和使用它。

private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
        Iterator var2 = parent.getChildren().iterator();

        while(var2.hasNext()) {
            XNode child = (XNode)var2.next();
            String interceptor = child.getStringAttribute("interceptor");
            Properties properties = child.getChildrenAsProperties();
            Interceptor interceptorInstance = (Interceptor)this.resolveClass(interceptor).getDeclaredConstructor().newInstance();
            interceptorInstance.setProperties(properties);
            this.configuration.addInterceptor(interceptorInstance);
        }
    }

}

1
2
3

public void addInterceptor(Interceptor interceptor) {
    this.interceptorChain.addInterceptor(interceptor);
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.plugin;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class InterceptorChain {
    private final List<Interceptor> interceptors = new ArrayList();

    public InterceptorChain() {
    }

    public Object pluginAll(Object target) {
        Interceptor interceptor;
        for(Iterator var2 = this.interceptors.iterator(); var2.hasNext(); target = interceptor.plugin(target)) {
            interceptor = (Interceptor)var2.next();
        }

        return target;
    }

    public void addInterceptor(Interceptor interceptor) {
        this.interceptors.add(interceptor);
    }

    public List<Interceptor> getInterceptors() {
        return Collections.unmodifiableList(this.interceptors);
    }
}

完成初始化的插件保存在这个List对象里面等待将其取出使用。

插件的代理和反射设计

1	executor = (Executor) interceptorChain.pluginAll(executor);

其通过plugin方法生成代理对象，责任链模式。

public Object pluginAll(Object target) {
    Interceptor interceptor;
    for(Iterator var2 = this.interceptors.iterator(); var2.hasNext(); target = interceptor.plugin(target)) {
        interceptor = (Interceptor)var2.next();
    }

    return target;
}

自己编写代理类工作量很大，为此MyBatis中提供了一个常用工具类，用来生成代理对象：Plugin

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.plugin;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.apache.ibatis.reflection.ExceptionUtil;
import org.apache.ibatis.util.MapUtil;

public class Plugin implements InvocationHandler {
    private final Object target;
    private final Interceptor interceptor;
    private final Map<Class<?>, Set<Method>> signatureMap;

    private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {
        this.target = target;
        this.interceptor = interceptor;
        this.signatureMap = signatureMap;
    }

    public static Object wrap(Object target, Interceptor interceptor) {
        Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
        Class<?> type = target.getClass();
        Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
        return interfaces.length > 0 ? Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap)) : target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            Set<Method> methods = (Set)this.signatureMap.get(method.getDeclaringClass());
            return methods != null && methods.contains(method) ? this.interceptor.intercept(new Invocation(this.target, method, args)) : method.invoke(this.target, args);
        } catch (Exception var5) {
            throw ExceptionUtil.unwrapThrowable(var5);
        }
    }

    private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
        Intercepts interceptsAnnotation = (Intercepts)interceptor.getClass().getAnnotation(Intercepts.class);
        if (interceptsAnnotation == null) {
            throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
        } else {
            Signature[] sigs = interceptsAnnotation.value();
            Map<Class<?>, Set<Method>> signatureMap = new HashMap();
            Signature[] var4 = sigs;
            int var5 = sigs.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                Signature sig = var4[var6];
                Set methods = (Set)MapUtil.computeIfAbsent(signatureMap, sig.type(), (k) -> {
                    return new HashSet();
                });

                try {
                    Method method = sig.type().getMethod(sig.method(), sig.args());
                    methods.add(method);
                } catch (NoSuchMethodException var10) {
                    throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + var10, var10);
                }
            }

            return signatureMap;
        }
    }

    private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
        HashSet interfaces;
        for(interfaces = new HashSet(); type != null; type = type.getSuperclass()) {
            Class[] var3 = type.getInterfaces();
            int var4 = var3.length;

            for(int var5 = 0; var5 < var4; ++var5) {
                Class<?> c = var3[var5];
                if (signatureMap.containsKey(c)) {
                    interfaces.add(c);
                }
            }
        }

        return (Class[])interfaces.toArray(new Class[0]);
    }
}

如果使用这个类为插件生成代理对象，那么代理对象在调用方法时就会进入到invoke方法中。在invoke方法中，如果存在签名的拦截方法，插件的intercept方法就会在这里调用，然后返回结果。如果不存在签名方法，那么将直接反射调度要执行的方法。

MyBatis把被代理对象、反射方法及其参数，都传递给了Invocation类的构造方法，用以生成一个Invocation类对象，其有一个proceed()方法。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.plugin;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Invocation {
    private final Object target;
    private final Method method;
    private final Object[] args;

    public Invocation(Object target, Method method, Object[] args) {
        this.target = target;
        this.method = method;
        this.args = args;
    }

    public Object getTarget() {
        return this.target;
    }

    public Method getMethod() {
        return this.method;
    }

    public Object[] getArgs() {
        return this.args;
    }

    public Object proceed() throws InvocationTargetException, IllegalAccessException {
        return this.method.invoke(this.target, this.args);
    }
}

如果有多个插件，那么通过wrap产生多层包装的代理对象。

常见工具类——MetaObject

MetaObject可以有效读取或者修改一些重要对象的属性。在MyBatis中，四大对象提供的public设置参数的方法很少难以通过其自身得到相关的属性信息，但是有了MetaObject这个工具类就可以通过其他的技术手段来读取或者修改这些重要对象的属性。

MetaObject有3个方法：

//用于包装对象，不再使用，用SystemMetaObject.froObject(Object obj)替换
public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
        return object == null ? SystemMetaObject.NULL_META_OBJECT : new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
}

//用于获取对象属性值，支持OGNL
public Object getValue(String name) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
        MetaObject metaValue = this.metaObjectForProperty(prop.getIndexedName());
        return metaValue == SystemMetaObject.NULL_META_OBJECT ? null : metaValue.getValue(prop.getChildren());
    } else {
        return this.objectWrapper.get(prop);
    }
}

//用于修改对象属性值，支持OGNL
public void setValue(String name, Object value) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
        MetaObject metaValue = this.metaObjectForProperty(prop.getIndexedName());
        if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
            if (value == null) {
                return;
            }

            metaValue = this.objectWrapper.instantiatePropertyValue(name, prop, this.objectFactory);
        }

        metaValue.setValue(prop.getChildren(), value);
    } else {
        this.objectWrapper.set(prop, value);
    }

}

StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
MetaObject metaStatementHandler = SystemMetaObject.forObject(statementHandler);
//进行绑定
//分离代理对象链（由于目标类可能被多个插件拦截，从而形成多次代理，通过循环可以分离出最原始的目标类）
while(metaStatementHandler.hasGetter("h")){
    Object object = metaStatementHandler.getValue("h");
    metaStatementHandler = SystemMetaObject.forObject(object);
}

//获取当前调用的SQL
String sql = (String) metaStatementHandler.getValue("delegate.boundSql.sql");
//判断SQL是否是select语句，如果不是select语句，则不需要处理
//如果是，则修改它，最多返回1000行，这里用的是MySQL数据库，其他数据库要改写成其他的
if(sql != null && sql.toLowerCase().trim().indexOf("select") == 0){
    //通过SQL重写来实现，这里我们起了一个奇怪的别名，避免与表名重复
    sql = "select * from (" + sql + ") $_$limit_$table_ limit 1000";
    metaStatementHandler.setValue("delegate.boundSql.sql", sql);
}

确定需要拦截的签名

MyBatis允许拦截四大对象中的任意一个对象，而通过Plugin源码，我们也看到了需要先注册签名才能使用插件，因此首先要确定需要拦截的对象，才能进一步确定需要配置什么样的签名，进而完成拦截的方法逻辑。

1、确定需要拦截的对象

Executor是执行SQL的全过程，包括组装参数、组装结果集返回和执行SQL过程，都可以拦截，较为广泛，一般用的不算太多。根据是否启动缓存参数，决定它是否使用CachingExecutor进行封装。
StatementHandler是执行SQL的过程，我们可以重写执行SQL的过程，它是最常用的拦截对象。
ParameterHandler主要拦截执行SQL的参数组装，我们可以重写组装参数规则。
ResultSetHandler用于拦截执行结果的组装，我们可以重写组装结果的规则。

2、拦截方法和参数
当确定了需要拦截什么对象，接下来就要确定需要拦截什么方法及方法的参数，这些都是在理解了MyBatis四大对象运作的基础上才确定的。
查询的过程是通过Executor调度StatementHandler来完成的。调度StatementHandler的prepare方法预编译SQL，于是要拦截的方法便是prepare方法，在此之前完成SQL的重新编写。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.executor.statement;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.session.ResultHandler;

public interface StatementHandler {
    Statement prepare(Connection var1, Integer var2) throws SQLException;

    void parameterize(Statement var1) throws SQLException;

    void batch(Statement var1) throws SQLException;

    int update(Statement var1) throws SQLException;

    <E> List<E> query(Statement var1, ResultHandler var2) throws SQLException;

    <E> Cursor<E> queryCursor(Statement var1) throws SQLException;

    BoundSql getBoundSql();

    ParameterHandler getParameterHandler();
}

以上的任何方法都可以拦截

设计拦截器

@Intercepts说明它是一个拦截器
@Signature是注册拦截器签名的地方，只有签名满足条件才能拦截
type可以是四大对象中的一个，这里是StatementHandler

method代表要拦截四大对象的某一种接口方法，而args

@Intercepts({
        @Signature(type=StatementHandler.class,
        method = "prepare",
        args = {Connection.class, Integer.class})})
class MyPlugin implements Interceptor{

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        return null;
    }
}

实现拦截方法

package mybatis;

import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.apache.log4j.Logger;

import java.sql.Connection;
import java.util.Properties;

@Intercepts({
        @Signature(type= StatementHandler.class,
                method = "prepare",
                args = {Connection.class, Integer.class})})
public class MyPlugin implements Interceptor {
    private Logger logger = Logger.getLogger(MyPlugin.class);
    private Properties properties = null;

    /**
     * 插件方法，它将代替StatementHandler的prepare方法
     * @param invocation 入参
     * @return 返回预编译后的PreparedStatement
     * @throws Throwable
     */
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
        //进行绑定
        MetaObject metaStatementHandler = SystemMetaObject.forObject(statementHandler);
        Object object = null;
        /*
        分离代理对象链，由于目标类可能被多个拦截器（插件）拦截，
        从而形成多次代理，通过循环可以分离出最原始的目标类
         */
        while(metaStatementHandler.hasGetter("h")){
            object = metaStatementHandler.getValue("h");
            metaStatementHandler = SystemMetaObject.forObject(object);
        }
        statementHandler = (StatementHandler) object;
        String sql = (String) metaStatementHandler.getValue("delegate.boundSql.sql");
        Long parameterObject = (Long) metaStatementHandler.getValue("delegate.boundSql.parameterObject");
        logger.info("执行的SQL：【" + sql + "】");
        logger.info("参数：【" + parameterObject + "】");
        logger.info("before ......");
        //如果当前代理的是一个非代理对象，那么它就回调用真实拦截对象的方法
        //如果不是，那么它会调度下个插件代理对象的invoke方法
        Object obj = invocation.proceed();
        logger.info("after ......");
        return obj;
    }

    /**
     * 生产代理对象
     * @param target 被代理的对象
     * @return 代理对象
     */
    @Override
    public Object plugin(Object target) {
        //采用系统默认的Plugin.wrap方法生成
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        this.properties = properties;
        logger.info("dbType = " + this.properties.get("dbType"));
    }
}

MyBatis的配置文件配置plugins元素，注意其配置顺序。

<plugins>
    <plugin interceptor="mybatis.MyPlugin">
        <property name="dbType" value="mysql"/>
    </plugin>
</plugins>

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=55183:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
 INFO 2021-09-10 22:25:11,638 mybatis.MyPlugin: dbType = mysql
DEBUG 2021-09-10 22:25:11,713 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-10 22:25:11,726 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-10 22:25:11,726 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-10 22:25:11,727 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-10 22:25:11,727 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-10 22:25:11,996 mybatis.RoleMapper: Cache Hit Ratio [mybatis.RoleMapper]: 0.0
DEBUG 2021-09-10 22:25:12,000 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-10 22:25:14,134 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 1163619825.
DEBUG 2021-09-10 22:25:14,134 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@455b6df1]
 INFO 2021-09-10 22:25:14,138 mybatis.MyPlugin: 执行的SQL：【select id, role_name as roleName, note note from t_role where id = ?】
 INFO 2021-09-10 22:25:14,138 mybatis.MyPlugin: 参数：【1】
 INFO 2021-09-10 22:25:14,138 mybatis.MyPlugin: before ......
DEBUG 2021-09-10 22:25:14,138 mybatis.RoleMapper.getRole: ==>  Preparing: select id, role_name as roleName, note note from t_role where id = ?
 INFO 2021-09-10 22:25:14,199 mybatis.MyPlugin: after ......
DEBUG 2021-09-10 22:25:14,200 mybatis.RoleMapper.getRole: ==> Parameters: 1(Long)
DEBUG 2021-09-10 22:25:14,281 mybatis.RoleMapper.getRole: <==      Total: 1
 INFO 2021-09-10 22:25:14,282 mybatis.SqlSessionFactoryUtils: John
 INFO 2021-09-10 22:25:14,282 mybatis.SqlSessionFactoryUtils: Hello World!
DEBUG 2021-09-10 22:25:14,286 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@455b6df1]
DEBUG 2021-09-10 22:25:14,287 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@455b6df1]
DEBUG 2021-09-10 22:25:14,287 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 1163619825 to pool.

Process finished with exit code 0

插件实例——分页插件

MyBatis中存在一个RowBounds用于分页，但是它是基于第一次查询结果的再分页，也就是先让SQL查询出所有的记录，然后分页，显然性能不高。

启动分页参数(PageParams)需要满足下列条件之一：

传递单个PageParams或者其子对象
map中存在一个值为PageParams或者其子对象
在MyBatis中传递多个参数，但其中之一为PageParams或者其子对象
传递单个POJO参数，这个POJO有一个属性为PageParams或者其子对象，且提供了setter和getter方法。

自定义PageParamsCustom类

package mybatis;

public class PageParamsCustom {
    //当前页码
    private Integer page;
    //每页限制条数
    private Integer pageSize;
    //是否启动插件，如果不启动，则不作分页
    private Boolean useFlag;
    //是否检测页码的有效性，如果为true，而页码大于最大页数，则抛出异常
    private Boolean checkFlag;
    //是否清楚最后order by后面的语句
    private Boolean cleanOrderBy;
    //总条数，插件会回填这个值
    private Integer total;
    //总页数，插件会回填这个值
    private Integer totalPage;

    public void setCheckFlag(Boolean checkFlag) {
        this.checkFlag = checkFlag;
    }

    public void setCleanOrderBy(Boolean cleanOrderBy) {
        this.cleanOrderBy = cleanOrderBy;
    }

    public void setPage(Integer page) {
        this.page = page;
    }

    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }

    public void setTotal(Integer total) {
        this.total = total;
    }

    public void setTotalPage(Integer totalPage) {
        this.totalPage = totalPage;
    }

    public void setUseFlag(Boolean useFlag) {
        this.useFlag = useFlag;
    }

    public Boolean getCheckFlag() {
        return checkFlag;
    }

    public Boolean getCleanOrderBy() {
        return cleanOrderBy;
    }

    public Boolean getUseFlag() {
        return useFlag;
    }

    public Integer getPage() {
        return page;
    }

    public Integer getPageSize() {
        return pageSize;
    }

    public Integer getTotal() {
        return total;
    }

    public Integer getTotalPage() {
        return totalPage;
    }
}

自定义PagePlugin类

package mybatis;

import org.apache.ibatis.executor.ExecutorException;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.apache.ibatis.scripting.defaults.DefaultParameterHandler;
import org.apache.ibatis.session.Configuration;

import javax.swing.plaf.nimbus.State;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

@Intercepts({
        @Signature(
                type = StatementHandler.class,
                method = "prepare",
                args = {Connection.class, Integer.class}
        )
})
public class PagePlugin implements Interceptor {
    /**
     * 插件默认参数，可配置默认值
     */
    private Integer defaultPage; //默认页码
    private Integer defaultPageSize; //默认每页条数
    private Boolean defaultUseFlag; //默认是否启用插件
    private Boolean defaultCheckFlag; //默认是否检测页码参数
    private Boolean defaultCleanOrderBy; //默认是否清楚最后一个order by后的语句

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler statementHandler = (StatementHandler) getUnProxyObject(invocation.getTarget());
        MetaObject metaStatementHandler = SystemMetaObject.forObject(statementHandler);
        String sql = (String) metaStatementHandler.getValue("delegate.boundSql.sql");
        MappedStatement mappedStatement = (MappedStatement) metaStatementHandler.getValue("delegate.mappedStatement");
        //不是select语句
        if(!checkSelect(sql)) return invocation.proceed();
        BoundSql boundSql = (BoundSql) metaStatementHandler.getValue("delegate.boundSql");
        Object parameterObject = boundSql.getParameterObject();
        PageParamsCustom pageParamsCustom = getPageParamsForParamObj(parameterObject);
        if(pageParamsCustom == null){
            //无法获取分页参数，不进行分页
            return invocation.proceed();
        }
        //获取配置中是否启用分页功能
        Boolean useFlag = pageParamsCustom.getUseFlag() == null ? this.defaultUseFlag : pageParamsCustom.getUseFlag();
        if(!useFlag){
            //不使用分页插件
            return invocation.proceed();
        }
        //获取相关配置的参数
        Integer pageNum = pageParamsCustom.getPage() == null ? defaultPage : pageParamsCustom.getPage();
        Integer pageSize = pageParamsCustom.getPageSize() == null ? defaultPageSize : pageParamsCustom.getPageSize();
        Boolean checkFlag = pageParamsCustom.getCheckFlag() == null ? defaultCheckFlag : pageParamsCustom.getCheckFlag();
        Boolean cleanOrderBy = pageParamsCustom.getCleanOrderBy() == null ? defaultCleanOrderBy : pageParamsCustom.getCleanOrderBy();
        //计算总条数
        int total = getTotal(invocation, metaStatementHandler, boundSql, cleanOrderBy);
        //回填总条数到分页参数
        pageParamsCustom.setTotal(total);
        //计算总页数
        int totalPage = total % pageSize == 0 ? total / pageSize : total / pageSize + 1;
        //回填总页数到分页参数
        pageParamsCustom.setTotalPage(totalPage);
        //检查当前页码的有效性
        checkPage(checkFlag, pageNum, totalPage);
        //修改sql
        return preparedSQL(invocation, metaStatementHandler, boundSql, pageNum, pageSize);
    }

    @Override
    public Object plugin(Object target) {
        //生成代理对象
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        //从配置中获取参数
        String strDefaultPage = properties.getProperty("default.page", "1");
        String strDefaultPageSize = properties.getProperty("default.pageSize", "50");
        String strDefaultUseFlag = properties.getProperty("default.useFlag", "false");
        String strDefaultCheckFlag = properties.getProperty("default.checkFlag", "false");
        String strDefaultCleanOrderBy = properties.getProperty("default.cleanOrderBy", "false");
        //设置默认参数
        this.defaultPage = Integer.parseInt(strDefaultPage);
        this.defaultPageSize = Integer.parseInt(strDefaultPageSize);
        this.defaultUseFlag = Boolean.parseBoolean(strDefaultUseFlag);
        this.defaultCheckFlag = Boolean.parseBoolean(strDefaultCheckFlag);
        this.defaultCleanOrderBy = Boolean.parseBoolean(strDefaultCleanOrderBy);
    }

    /**
     * 从代理对象中分离出真实对象
     *
     * @param target invocation
     * @return 非代理StatementHandler对象
     */
    private Object getUnProxyObject(Object target) {
        MetaObject metaStatementHandler = SystemMetaObject.forObject(target);
        //分离代理对象链（由于目标类可能被多个拦截器拦截，从而形成多次代理，通过循环可以分离出最原始的目标类
        Object object = null;
        while (metaStatementHandler.hasGetter("h")) {
            object = metaStatementHandler.getValue("h");
            metaStatementHandler = SystemMetaObject.forObject(object);
        }
        if (object == null) return target;
        return object;
    }

    /**
     * 判断是否sql语句
     *
     * @param sql 当前执行的SQL
     * @return 是否查询语句
     */
    private boolean checkSelect(String sql) {
        String trimSql = sql.trim();
        int idx = trimSql.toLowerCase().indexOf("select");
        return idx == 0;
    }

    public PageParamsCustom getPageParamsForParamObj(Object parameterObject) throws Exception {
        PageParamsCustom pageParams = null;
        if (parameterObject == null) return null;

        //处理map参数，多个匿名参数和@Param注解参数，都是map
        if (parameterObject instanceof Map) {
            @SuppressWarnings("unchecked") Map<String, Object> paramMap = (Map<String, Object>) parameterObject;
            Set<String> keySet = paramMap.keySet();
            Iterator<String> iterator = keySet.iterator();
            while (iterator.hasNext()) {
                String key = iterator.next();
                Object value = paramMap.get(key);
                if (value instanceof PageParamsCustom) return (PageParamsCustom) value;
            }
        } else if (parameterObject instanceof PageParamsCustom) {
            //参数是或者继承PageParamsCustom
            return (PageParamsCustom) parameterObject;
        } else {
            //从POJO属性尝试读取分页参数
            Field[] fields = parameterObject.getClass().getDeclaredFields();
            //尝试从POJO中获得类型为PageParamsCustom的属性
            for (Field field : fields) {
                if (field.getType() == PageParamsCustom.class) {
                    PropertyDescriptor propertyDescriptor = new PropertyDescriptor(field.getName(), parameterObject.getClass());
                    Method method = propertyDescriptor.getReadMethod();
                    return (PageParamsCustom) method.invoke(parameterObject);
                }
            }
        }
        return pageParams;
    }

    private int getTotal(Invocation invocation, MetaObject metaStatementHandler, BoundSql boundSql, Boolean cleanOrderBy) throws Throwable {
        //获取当前的mappedStatement
        MappedStatement mappedStatement = (MappedStatement) metaStatementHandler.getValue("delegate.mappedStatement");
        //配置对象
        Configuration configuration = mappedStatement.getConfiguration();
        //当前需要执行的SQL
        String sql = (String) metaStatementHandler.getValue("delegate.boundSql.sql");
        //去掉最后的order by语句
        if (cleanOrderBy) sql = this.cleanOrderByForSql(sql);
        //改写为统计总数的SQL
        String countSql = "select count(*) as total from (" + sql + ") $_paging";
        //获取拦截方法参数，根据插件签名，知道是Connection对象
        Connection connection = (Connection) invocation.getArgs()[0];
        PreparedStatement preparedStatement = null;
        int total = 0;
        try {
            //预编译统计总数SQL
            preparedStatement = connection.prepareStatement(countSql);
            //构建统计总数BoundSql
            BoundSql countBoundSql = new BoundSql(configuration, countSql, boundSql.getParameterMappings(),
                    boundSql.getParameterObject());
            //构建MyBatis的ParameterHandler用来设置总数Sql的参数
            ParameterHandler handler = new DefaultParameterHandler(mappedStatement, boundSql.getParameterObject(), countBoundSql);
            //设置总数SQL参数
            handler.setParameters(preparedStatement);
            //执行查询
            ResultSet resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) total = resultSet.getInt("total");
        } finally {
            //这里不能关闭Connection，否则后续的SQL就没法继续了
            if (preparedStatement != null) preparedStatement.close();
        }
        return total;
    }

    private String cleanOrderByForSql(String sql) {
        StringBuilder stringBuilder = new StringBuilder(sql);
        String newSql = sql.toLowerCase();
        //如果没有order语句，则直接返回
        if (!newSql.contains("order")) return sql;
        int idx = newSql.lastIndexOf("order");
        return stringBuilder.substring(0, idx).toString();
    }

    private void checkPage(Boolean checkFlag, Integer pageNum, Integer pageTotal) throws Throwable {
        if (checkFlag) {
            //检查页码page是否合法
            if (pageNum > pageTotal) {
                throw new Exception("查询失败，查询页码【" + pageNum + "】大于总页数【" + pageTotal + "】!!");
            }
        }
    }

    private Object preparedSQL(Invocation invocation, MetaObject metaStatementHandler, BoundSql boundSql, int pageNum, int pageSize) throws Exception {
        //获取当前需要执行的SQL
        String sql = boundSql.getSql();
        String newSql = "select * from (" + sql + ") $_paging_table limit ?,?";
        //修改当前需要执行的SQL
        metaStatementHandler.setValue("delegate.boundSql.sql", newSql);
        //执行编译，相当于StatementHandler执行了prepared()方法，这个时候，就剩下两个分页参数没有设置
        Object statementObj = invocation.proceed();
        //设置两个分页参数
        this.preparePageDataParams((PreparedStatement) statementObj, pageNum, pageSize);
        return statementObj;
    }

    private void preparePageDataParams(PreparedStatement preparedStatement, int pageNum, int pageSize) throws Exception {
        //prepared()方法编译SQL，由于MyBatis上下文没有分页参数的信息，所以这里需要设置这两个参数
        //获取需要设置的参数个数，由于参数是最后的两个，所以很容易得到其位置
        int idx = preparedStatement.getParameterMetaData().getParameterCount();
        //最后两个是分页参数
        preparedStatement.setInt(idx - 1, (pageNum - 1) * pageSize); //开始行
        preparedStatement.setInt(idx, pageSize); //限制条数
    }
}

mapper设置以及启动程序

配置文件设置

<plugins>
      <plugin interceptor="mybatis.PagePlugin">
          <!--默认页码-->
          <property name="default.page" value="1"/>
          <!--默认每页条数-->
          <property name="default.pageSize" value="20"/>
          <!--默认每页条数-->
          <property name="default.useFlag" value="true"/>
          <!--是否检查页码有效性，如果非有效，则抛出异常-->
          <property name="default.checkFlag" value="false"/>
          <!--针对哪些含有order by的SQL，是否去掉最后一个order by以后的SQL语句，提高性能-->
          <property name="default.cleanOrderBy" value="false"/>
      </plugin>
  </plugins>

Logger logger = Logger.getLogger(SqlSessionFactoryUtils.class);
SqlSession sqlSession = null;
SqlSession sqlSession1 = null;
try {
    sqlSession = SqlSessionFactoryUtils.openSqlSession();
    RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
    PageParamsCustom pageParams = new PageParamsCustom();
    pageParams.setPageSize(10);
    List<Role> roleList = roleMapper.findRoles(pageParams, "John");
    logger.info(roleList.size());
} catch (Exception e){
    logger.info(e.getMessage(), e);
    sqlSession.rollback();
}finally {
    if(sqlSession != null) sqlSession.close();
}

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=49924:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaTest\out\production\JavaTest;D:\download\cglib-nodep-3.3.0.jar;D:\download\fastjson-1.2.76.jar;D:\download\commons-lang3-3.12.0.jar;D:\download\mybatis-3.5.7\mybatis-3.5.7.jar;D:\download\mysql-connector-java-8.0.19.jar;D:\download\mybatis-3.5.7\lib\asm-7.1.jar;D:\download\mybatis-3.5.7\lib\cglib-3.3.0.jar;D:\download\mybatis-3.5.7\lib\ognl-3.2.20.jar;D:\download\mybatis-3.5.7\lib\log4j-1.2.17.jar;D:\download\mybatis-3.5.7\lib\log4j-api-2.14.1.jar;D:\download\mybatis-3.5.7\lib\slf4j-api-1.7.30.jar;D:\download\mybatis-3.5.7\lib\log4j-core-2.14.1.jar;D:\download\mybatis-3.5.7\lib\commons-logging-1.2.jar;D:\download\mybatis-3.5.7\lib\javassist-3.27.0-GA.jar;D:\download\mybatis-3.5.7\lib\slf4j-log4j12-1.7.30.jar;D:\download\commons-dbcp2-2.9.0\commons-dbcp2-2.9.0.jar mybatis.SqlSessionFactoryUtils
DEBUG 2021-09-11 21:22:16,357 org.apache.ibatis.logging.LogFactory: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
DEBUG 2021-09-11 21:22:16,373 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-11 21:22:16,373 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-11 21:22:16,373 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-11 21:22:16,373 org.apache.ibatis.datasource.pooled.PooledDataSource: PooledDataSource forcefully closed/removed all connections.
DEBUG 2021-09-11 21:22:16,467 mybatis.RoleMapper: Cache Hit Ratio [mybatis.RoleMapper]: 0.0
DEBUG 2021-09-11 21:22:16,471 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Opening JDBC Connection
DEBUG 2021-09-11 21:22:16,832 org.apache.ibatis.datasource.pooled.PooledDataSource: Created connection 1508181426.
DEBUG 2021-09-11 21:22:16,832 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@59e505b2]
DEBUG 2021-09-11 21:22:16,836 mybatis.RoleMapper.findRoles: ==>  Preparing: select count(*) as total from (select id, role_name as roleName, note from t_role where role_name like concat('%', ?, '%')) $_paging
DEBUG 2021-09-11 21:22:16,863 mybatis.RoleMapper.findRoles: ==> Parameters: John(String)
DEBUG 2021-09-11 21:22:16,946 mybatis.RoleMapper.findRoles: <==      Total: 1
DEBUG 2021-09-11 21:22:16,947 mybatis.RoleMapper.findRoles: ==>  Preparing: select * from (select id, role_name as roleName, note from t_role where role_name like concat('%', ?, '%')) $_paging_table limit ?,?
DEBUG 2021-09-11 21:22:16,948 mybatis.RoleMapper.findRoles: ==> Parameters: 0(Integer), 10(Integer), John(String)
DEBUG 2021-09-11 21:22:16,952 mybatis.RoleMapper.findRoles: <==      Total: 2
 INFO 2021-09-11 21:22:16,952 mybatis.SqlSessionFactoryUtils: 2
DEBUG 2021-09-11 21:22:16,957 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@59e505b2]
DEBUG 2021-09-11 21:22:16,958 org.apache.ibatis.transaction.jdbc.JdbcTransaction: Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@59e505b2]
DEBUG 2021-09-11 21:22:16,958 org.apache.ibatis.datasource.pooled.PooledDataSource: Returned connection 1508181426 to pool.

Process finished with exit code 0

Spring 基础

Spring IoC概述

IoC：Inverse of Control 控制反转

Spring IoC容器

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.beans.factory;

import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;

public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";

    Object getBean(String var1) throws BeansException;

    <T> T getBean(String var1, Class<T> var2) throws BeansException;

    Object getBean(String var1, Object... var2) throws BeansException;

    <T> T getBean(Class<T> var1) throws BeansException;

    <T> T getBean(Class<T> var1, Object... var2) throws BeansException;

    <T> ObjectProvider<T> getBeanProvider(Class<T> var1);

    <T> ObjectProvider<T> getBeanProvider(ResolvableType var1);

    boolean containsBean(String var1);

    boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;

    boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;

    @Nullable
    Class<?> getType(String var1) throws NoSuchBeanDefinitionException;

    @Nullable
    Class<?> getType(String var1, boolean var2) throws NoSuchBeanDefinitionException;

    String[] getAliases(String var1);
}

getBean的多个方法用于获取配置给SpringIoC容器的Bean。从参数类型看可以使字符串，也可以是Class类型，由于Class类型可以扩展接口也可以集成父类，所以在一定程度上会存在使用父类类型无法准确获得实例的异常，比如获取学生类，但是学生子类有男学生和女学生两类，这个时候通过学生类就无法从容器中得到实例，因为容器无法判断具体的实现类。
isSingleton用于判断是否单例，如果判断为真，其意思是该Bean的容器中是作为一个唯一单例存在的。而isPrototype则相反，如果判断为真，意思是当你从容其中获取Bean，容器就为你生成了一个新的实例。在默认情况下，Spring会为Bean创建一个单例，也就是默认情况下isSingleton返回true，而isPrototype返回false。
关于type的匹配，这是一个按Java类型匹配的方式。
getAliases方法是获取别名的方法。

Spring IoC容器的初始化和依赖注入

Bean的初始化分为3步：
（1）Resource定位，这步是Spring IoC容器根据开发者的配置，进行资源定位，在Spring的开发中，通过XML或者注解都是十分常见的方式，定位的内容是由开发者所提供的。
（2）BeanDefinition的载入，这个过程就是Spring根据开发者的配置获取对应的POJO，用以生成对应实例的过程。
（3）BeanDefinition的注册，这个步骤就相当于把之前通过BeanDefinition载入的POJO往Spring IoC容器中注册，这样就可以使得开发和测试人员都可以通过描述从中得到Spring IoC容器的Bean了。
以上3步完成后，Bean就在Spring IoC容器中得到了初始化，但是没有完全依赖注入，也就是没有注入其配置的资源给Bean，那么它还不能完全使用。对于依赖注入，Spring Bean还有一个配置选项——lazy-init，其含义就是是否初始化Spring Bean，默认false，即默认自动初始化Bean。否则，只有当我们通过Spring IoC容器的getBean方法获取它时，它才会进行初始化，完成依赖注入。

依赖注入实例

package com.louris.springboot.IoCImpl.beans.pojo;

public class JuiceMaker {

    private String beverageShop = null;
    private Source source = null;


    public void setBeverageShop(String beverageShop) {
        this.beverageShop = beverageShop;
    }

    public void setSource(Source source) {
        this.source = source;
    }

    public Source getSource() {
        return source;
    }

    public String getBeverageShop() {
        return beverageShop;
    }

    public String makeJuice(){
        String juice = "这是一杯由" + beverageShop + "饮品店，提供的" + source.getSize() + source.getSugar() + source.getFruit();
        return juice;
    }
}

package com.louris.springboot.IoCImpl.beans.pojo;

public class Source {
    private String fruit;
    private String sugar;
    private Integer size;

    public void setFruit(String fruit) {
        this.fruit = fruit;
    }

    public void setSize(Integer size) {
        this.size = size;
    }

    public void setSugar(String sugar) {
        this.sugar = sugar;
    }

    public Integer getSize() {
        return size;
    }

    public String getFruit() {
        return fruit;
    }

    public String getSugar() {
        return sugar;
    }
}

spring-config.xml，该文件在resources目录下，因为默认springboot读取扫描resources下的xml和其他资源文件，否则需要配置pom.xml的resources标签指定扫描目录：

<build>
        <!-- 手动指定文件夹为resources -->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <!--      MyBatis代码自动生成插件      -->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.6</version>
                <configuration>
                    <!--   配置文件的位置                 -->
                    <configurationFile>GeneratorMapper.xml</configurationFile>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

spring-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="source" class="com.louris.springboot.IoCImpl.beans.pojo.Source">
    <property name="fruit" value="橙汁"/>
    <property name="sugar" value="少糖"/>
    <property name="size" value="2"/>
</bean>
<bean id="juiceMaker" class="com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker">
    <property name="beverageShop" value="贡茶"/>
    <property name="source" ref="source"/>
</bean>
</beans>

package com.louris.springboot;

import com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

//SpringBoot项目启动入口类
@SpringBootApplication  //SpringBoot核心朱姐，主要用于开启spring自动配置
public class Application {

    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
        JuiceMaker juiceMaker = (JuiceMaker) applicationContext.getBean("juiceMaker");
        System.out.println(juiceMaker.makeJuice());
    }

}

运行结果：

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=57146:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\SpringBootCourse\001-springboot-first\target\classes;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.4.4\spring-boot-starter-web-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter\2.4.4\spring-boot-starter-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.4.4\spring-boot-autoconfigure-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.4.4\spring-boot-starter-logging-2.4.4.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.13.3\log4j-to-slf4j-2.13.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-api\2.13.3\log4j-api-2.13.3.jar;C:\Users\98383\.m2\repository\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;C:\Users\98383\.m2\repository\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;C:\Users\98383\.m2\repository\org\yaml\snakeyaml\1.27\snakeyaml-1.27.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.4.4\spring-boot-starter-json-2.4.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.11.4\jackson-databind-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.11.4\jackson-annotations-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.11.4\jackson-core-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.11.4\jackson-datatype-jdk8-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.11.4\jackson-datatype-jsr310-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.11.4\jackson-module-parameter-names-2.11.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.4.4\spring-boot-starter-tomcat-2.4.4.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\9.0.44\tomcat-embed-core-9.0.44.jar;C:\Users\98383\.m2\repository\org\glassfish\jakarta.el\3.0.3\jakarta.el-3.0.3.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.44\tomcat-embed-websocket-9.0.44.jar;C:\Users\98383\.m2\repository\org\springframework\spring-web\5.3.5\spring-web-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-webmvc\5.3.5\spring-webmvc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-aop\5.3.5\spring-aop-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-expression\5.3.5\spring-expression-5.3.5.jar;C:\Users\98383\.m2\repository\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\98383\.m2\repository\org\springframework\spring-core\5.3.5\spring-core-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jcl\5.3.5\spring-jcl-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-beans\5.3.5\spring-beans-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot\2.4.4\spring-boot-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-context\5.3.5\spring-context-5.3.5.jar com.louris.springboot.Application
Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  `  |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/

 :: Spring Boot ::                (v2.4.4)

2021-09-13 14:51:24.036  INFO 11752 --- [           main] com.louris.springboot.Application        : Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 11752 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-13 14:51:24.038  INFO 11752 --- [           main] com.louris.springboot.Application        : No active profile set, falling back to default profiles: default
2021-09-13 14:51:24.627  INFO 11752 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2021-09-13 14:51:24.633  INFO 11752 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-13 14:51:24.633  INFO 11752 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-13 14:51:24.692  INFO 11752 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-13 14:51:24.692  INFO 11752 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 624 ms
2021-09-13 14:51:24.786  INFO 11752 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-09-13 14:51:24.881  INFO 11752 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-09-13 14:51:24.888  INFO 11752 --- [           main] com.louris.springboot.Application        : Started Application in 1.066 seconds (JVM running for 1.431)
这是一杯由贡茶饮品店，提供的2少糖橙汁

Spring Bean的生命周期

Spring IoC容器在执行了初始化和依赖注入后，会执行一定的步骤来完成初始化，通过这些步骤我们就能自定义初始化，而在Spring IoC容器正常关闭的时候，它也会执行一定的步骤来关闭容器，释放资源。除需要了解整个生命周期的步骤外，还要知道这些生命周期的接口是针对什么而言的，首先介绍生命周期的步骤。

如果Bean实现了接口BeanNameAware的setBeanName方法，那么它就会调用这个方法。
如果Bean实现了接口BeanFactoryAware的setBeanFactory方法，那么它就会调用这个方法。
如果Bean实现了接口ApplicationContextAware的setApplicationContext方法，且Spring IoC容器也必须是一个ApplicationContext接口的实现类，那么才会调用这个方法，否则是不调用的。
如果Bean实现了接口BeanPostProcessor的postProcessBeforeInitialization方法，那么它就会调用这个方法。
如果Bean实现了接口BeanFactoryPostProcessor的afterPropertiesSet方法，那么它就会调用这个方法。
如果Bean自定义了初始化方法，它就会调用已定义的初始化方法。
如果Bean实现了接口BeanPostProcessor的postProcessAfterInitialization方法，完成了这些调用，这个时候Bean就完成了初始化，那么Bean就生存在Spring IoC的容器中了，使用者就可以从中获取Bean的服务。

当服务器正常关闭，或者遇到其他关闭Spring IoC容器的事件，它就会调用对应的方法完成Bean的销毁，步骤如下：

如果Bean实现了接口DisposableBean的destroy方法，那么就会调用它。
如果定义了自定义销毁方法，那么就会调用它。

因为有些步骤是在一些条件下才会执行的，如果不注意这些，往往就发现命名实现了一些借口，但是该方法并没有被执行。所有的Spring IoC容器最低的要求是实现BeanFactory接口而已，而非ApplicationContext接口，如果采用了非ApplicationContext子类创建Spring IoC容器，俺么即使是实现了ApplicationContextAware的setApplicationContext方法，它也不会在生命周期之中被调用。

此外，还要注意这些接口是针对什么而言的，上述生命周期的接口，大部分是针对单个Bean而言的；BeanPostProcessor接口则是针对所有Bean而言的；接口DisposableBean则是针对Spring IoC容器本身。当一个Bean实现了上述的接口，我们只需要在Spring IoC容器中定义它就可以了，Spring IoC容器会自动识别。

测试实现

package com.louris.springboot.IoCImpl.beans.pojo;

public class Source {
    private String fruit;
    private String sugar;
    private Integer size;

    public void setFruit(String fruit) {
        this.fruit = fruit;
    }

    public void setSize(Integer size) {
        this.size = size;
    }

    public void setSugar(String sugar) {
        this.sugar = sugar;
    }

    public Integer getSize() {
        return size;
    }

    public String getFruit() {
        return fruit;
    }

    public String getSugar() {
        return sugar;
    }
}

package com.louris.springboot.IoCImpl.beans.pojo;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class JuiceMaker2 implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean {

    private String beverageShop = null;
    private Source source = null;


    public void setBeverageShop(String beverageShop) {
        this.beverageShop = beverageShop;
    }

    public void setSource(Source source) {
        this.source = source;
    }

    public Source getSource() {
        return source;
    }

    public String getBeverageShop() {
        return beverageShop;
    }

    public void init(){
        System.out.println("【" + this.getClass().getSimpleName() + "】执行自定义初始化方法");
    }

    public void destroy(){
        System.out.println("【" + this.getClass().getSimpleName() + "】执行自定义销毁方法");
    }

    public String makeJuice(){
        String juice = "这是一杯由" + beverageShop + "饮品店，提供的" + source.getSize() + source.getSugar() + source.getFruit();
        return juice;
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("【" + this.getClass().getSimpleName() + "】调用BeanNameAware接口的setBeanName方法");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("【" + this.getClass().getSimpleName() + "】调用BeanFactoryAware接口的setBeanFactory方法");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("【" + this.getClass().getSimpleName() + "】调用ApplicationContextAware接口的setApplicationContext方法");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【" + this.getClass().getSimpleName() + "】调用Initializing接口的afterPropertiesSet方法");
    }
}

package com.louris.springboot.IoCImpl;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * 处理Spring IoC容器所有的Bean
 */
public class BeanPostProcessorImpl implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【"+ bean.getClass().getSimpleName() + "】对象" + beanName + "开始初始化");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【"+bean.getClass().getSimpleName() + "】对象" + beanName + "实例化完成");
        return bean;
    }
}

package com.louris.springboot.IoCImpl;

import org.springframework.beans.factory.DisposableBean;

/**
 * 针对Spring IoC容器销毁的
 */
public class DisposableBeanImpl implements DisposableBean {

    @Override
    public void destroy() throws Exception {
        System.out.println("调用接口DisposableBean的destroy方法");
    }
}

package com.louris.springboot;

import com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker;
import com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker2;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

//SpringBoot项目启动入口类
@SpringBootApplication  //SpringBoot核心朱姐，主要用于开启spring自动配置
public class Application {

    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
        JuiceMaker2 juiceMaker2 = (JuiceMaker2) applicationContext.getBean("juiceMaker2");
        System.out.println(juiceMaker2.makeJuice());
        applicationContext.close();
    }

}

执行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=54012:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\SpringBootCourse\001-springboot-first\target\classes;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.4.4\spring-boot-starter-web-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter\2.4.4\spring-boot-starter-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.4.4\spring-boot-autoconfigure-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.4.4\spring-boot-starter-logging-2.4.4.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.13.3\log4j-to-slf4j-2.13.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-api\2.13.3\log4j-api-2.13.3.jar;C:\Users\98383\.m2\repository\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;C:\Users\98383\.m2\repository\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;C:\Users\98383\.m2\repository\org\yaml\snakeyaml\1.27\snakeyaml-1.27.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.4.4\spring-boot-starter-json-2.4.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.11.4\jackson-databind-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.11.4\jackson-annotations-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.11.4\jackson-core-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.11.4\jackson-datatype-jdk8-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.11.4\jackson-datatype-jsr310-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.11.4\jackson-module-parameter-names-2.11.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.4.4\spring-boot-starter-tomcat-2.4.4.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\9.0.44\tomcat-embed-core-9.0.44.jar;C:\Users\98383\.m2\repository\org\glassfish\jakarta.el\3.0.3\jakarta.el-3.0.3.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.44\tomcat-embed-websocket-9.0.44.jar;C:\Users\98383\.m2\repository\org\springframework\spring-web\5.3.5\spring-web-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-webmvc\5.3.5\spring-webmvc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-aop\5.3.5\spring-aop-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-expression\5.3.5\spring-expression-5.3.5.jar;C:\Users\98383\.m2\repository\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\98383\.m2\repository\org\springframework\spring-core\5.3.5\spring-core-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jcl\5.3.5\spring-jcl-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-beans\5.3.5\spring-beans-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot\2.4.4\spring-boot-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-context\5.3.5\spring-context-5.3.5.jar com.louris.springboot.Application
Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  `  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.4)

2021-09-13 15:33:11.074  INFO 10084 --- [           main] com.louris.springboot.Application        : Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 10084 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-13 15:33:11.076  INFO 10084 --- [           main] com.louris.springboot.Application        : No active profile set, falling back to default profiles: default
2021-09-13 15:33:11.780  INFO 10084 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2021-09-13 15:33:11.787  INFO 10084 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-13 15:33:11.787  INFO 10084 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-13 15:33:11.856  INFO 10084 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-13 15:33:11.856  INFO 10084 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 752 ms
2021-09-13 15:33:11.958  INFO 10084 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-09-13 15:33:12.059  INFO 10084 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-09-13 15:33:12.066  INFO 10084 --- [           main] com.louris.springboot.Application        : Started Application in 1.212 seconds (JVM running for 1.614)
【DisposableBeanImpl】对象disposableBean开始初始化
【DisposableBeanImpl】对象disposableBean实例化完成
【Source】对象source开始初始化
【Source】对象source实例化完成
【JuiceMaker】对象juiceMaker开始初始化
【JuiceMaker】对象juiceMaker实例化完成
【JuiceMaker2】调用BeanNameAware接口的setBeanName方法
【JuiceMaker2】调用BeanFactoryAware接口的setBeanFactory方法
【JuiceMaker2】调用ApplicationContextAware接口的setApplicationContext方法
【JuiceMaker2】对象juiceMaker2开始初始化
【JuiceMaker2】调用Initializing接口的afterPropertiesSet方法
【JuiceMaker2】执行自定义初始化方法
【JuiceMaker2】对象juiceMaker2实例化完成
这是一杯由贡茶饮品店，提供的2少糖橙汁
【JuiceMaker2】执行自定义销毁方法
调用接口DisposableBean的destroy方法

装配Spring Bean

依赖注入的3种方式

构造器注入

构造器注入依赖于构造方法实现，而构造方法可以是有参数的或者是无参数的。在大部分的情况下，我们都是通过类的构造方法来创建类对象，Spring也可以采用反射的方式，通过使用构造方式来完成注入，这就是构造器注入的原理。

为了让Spring完成对应的构造注入，我们有必要去描述具体的类、构造方法并设置对应的参数，这样Spring就会通过对应的信息用反射的形式创建对象。

package com.louris.springboot.IoCImpl.beans.pojo;

public class Role {
    private Long id;
    private String roleName;
    private String note;
    public Role(String roleName, String note){
        this.roleName = roleName;
        this.note = note;
    }

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

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public void setNote(String note) {
        this.note = note;
    }

    public String getRoleName() {
        return roleName;
    }

    public String getNote() {
        return note;
    }

    public Long getId() {
        return id;
    }
}

<bean id="role" class="com.louris.springboot.IoCImpl.beans.pojo.Role">
    <constructor-arg index="0" value="总经理"/>
    <constructor-arg index="1" value="公司管理者"/>
</bean>

constructor-arg元素用于定义类构造方法的参数，其中index用于定义参数的位置，而value则是设置值，通过这样的定义Spring便知道使用Role对应的构造方法创建对象。
缺点是如果参数很多，构造方法就比较复杂

使用setter注入

setter注入是Spring中最主流的注入方式。首先可以把构造方法声明为无参数的，然后使用setter注入为其设置对应的值，其实也是通过Java反射技术得以实现的。

<bean id="role" class="com.louris.springboot.IoCImpl.beans.pojo.Role">
    <property name="roleName" value="高级工程师"/>
    <property name="note" value="重要人员"/>
</bean>

接口注入

有些时候资源并非来自于自身系统，而是来自于外界，比如数据库连接资源完全可以在Tomcat下配置，然后通过JNDI的形式去获取它，这样数据库连接资源是属于开发工程外的资源，这个时候可以采用接口注入的形式来获取它。

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName">
        <value>java:comp/env/jdbc/ssm</value>
    </property>
</bean>

装配Bean概述

Spring中提供了3种方法进行配置装配Bean到Spring IoC容器：

在XML中显示配置；
在Java的接口和类中实现配置；
隐式Bean的发现机制和自动装配原则；

明确3种方式的优先级：
（1）基于约定优于配置的原则，最优先的应该是通过隐式Bean的发现机制和自动装配的原则。减少程序开发者的决定权，简单又不是灵活；
（2）在没有办法使用自动装配原则的情况下应该优先考虑Java接口和类中实现配置，避免XML配置的泛滥。典型场景的例子是一个父类有多个子类，通过IoC容器初始化一个子类，容器将无法知道使用哪个子类去初始化，这个时候可以使用Java的注解配置去指定。
（3）在上述方法都无法使用的情况下，那么只能选择XML去配置Spring IoC容器。由于现实工作中常常用到第三方的类库，有些类并不是我们开发的，我们无法修改里面的代码，这个时候就通过XML的方式配置使用了。

通过XML配置装配Bean

简单配置类对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="beanPostProcessor" class="com.louris.springboot.IoCImpl.BeanPostProcessorImpl"/>
    <bean id="disposableBean" class="com.louris.springboot.IoCImpl.DisposableBeanImpl"/>
    <bean id="source" class="com.louris.springboot.IoCImpl.beans.pojo.Source">
        <property name="fruit" value="橙汁"/>
        <property name="sugar" value="少糖"/>
        <property name="size" value="2"/>
    </bean>
    <bean id="juiceMaker" class="com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker">
        <property name="beverageShop" value="贡茶"/>
        <property name="source" ref="source"/>
    </bean>
    <bean id="juiceMaker2" class="com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker2" init-method="init" destroy-method="destroy">
        <property name="beverageShop" value="贡茶"/>
        <property name="source" ref="source"/>
    </bean>
    <bean id="role" class="com.louris.springboot.IoCImpl.beans.pojo.Role">
        <!--<constructor-arg index="0" value="总经理"/>-->
        <!--<constructor-arg index="1" value="公司管理者"/>-->
        <property name="roleName" value="高级工程师"/>
        <property name="note" value="重要人员"/>
    </bean>
    <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName">
            <value>java:comp/env/jdbc/ssm</value>
        </property>
    </bean>
</beans>

装配集合等复杂对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="beanPostProcessor" class="com.louris.springboot.IoCImpl.BeanPostProcessorImpl"/>
    <bean id="disposableBean" class="com.louris.springboot.IoCImpl.DisposableBeanImpl"/>
    <bean id="source" class="com.louris.springboot.IoCImpl.beans.pojo.Source">
        <property name="fruit" value="橙汁"/>
        <property name="sugar" value="少糖"/>
        <property name="size" value="2"/>
    </bean>
    <bean id="juiceMaker" class="com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker">
        <property name="beverageShop" value="贡茶"/>
        <property name="source" ref="source"/>
    </bean>
    <bean id="juiceMaker2" class="com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker2" init-method="init" destroy-method="destroy">
        <property name="beverageShop" value="贡茶"/>
        <property name="source" ref="source"/>
    </bean>
    <bean id="role" class="com.louris.springboot.IoCImpl.beans.pojo.Role">
        <!--<constructor-arg index="0" value="总经理"/>-->
        <!--<constructor-arg index="1" value="公司管理者"/>-->
        <property name="roleName" value="高级工程师"/>
        <property name="note" value="重要人员"/>
    </bean>
    <!--<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">-->
    <!--    <property name="jndiName">-->
    <!--        <value>java:comp/env/jdbc/ssm</value>-->
    <!--    </property>-->
    <!--</bean>-->

    <bean id="complexAssembly" class="com.louris.springboot.IoCImpl.beans.pojo.ComplexAssembly">
        <property name="id" value="1"/>
        <property name="list">
            <list>
                <value>value-list-1</value>
                <value>value-list-2</value>
                <value>value-list-3</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="key1" value="value-key-1"/>
                <entry key="key2" value="value-key-2"/>
                <entry key="key3" value="value-key-3"/>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="prop1">value-prop-1</prop>
                <prop key="prop2">value-prop-2</prop>
                <prop key="prop3">value-prop-3</prop>
            </props>
        </property>
        <property name="set">
            <set>
                <value>value-set-1</value>
                <value>value-set-2</value>
                <value>value-set-3</value>
            </set>
        </property>
        <property name="array">
            <array>
                <value>value-array-1</value>
                <value>value-array-2</value>
                <value>value-array-3</value>
            </array>
        </property>
    </bean>

    <bean id="role1" class="com.louris.springboot.IoCImpl.beans.pojo.Role">
        <property name="id" value="1"/>
        <property name="roleName" value="role_name_1"/>
        <property name="note" value="role_note_1"/>
    </bean>

    <bean id="role2" class="com.louris.springboot.IoCImpl.beans.pojo.Role">
        <property name="id" value="2"/>
        <property name="roleName" value="role_name_2"/>
        <property name="note" value="note_note_2"/>
    </bean>

    <bean id="user1" class="com.louris.springboot.IoCImpl.beans.pojo.User">
        <property name="id" value="1"/>
        <property name="userName" value="user_name_1"/>
        <property name="note" value="role_note_1"/>
    </bean>

    <bean id="user2" class="com.louris.springboot.IoCImpl.beans.pojo.User">
        <property name="id" value="2"/>
        <property name="userName" value="user_name_2"/>
        <property name="note" value="role_note_1"/>
    </bean>

    <bean id="userRoleAssembly" class="com.louris.springboot.IoCImpl.beans.pojo.UserRoleAssembly">
        <property name="id" value="1"/>
        <property name="list">
            <list>
                <ref bean="role1"/>
                <ref bean="role2"/>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key-ref="role1" value-ref="user1"/>
                <entry key-ref="role2" value-ref="user2"/>
            </map>
        </property>
        <property name="set">
            <set>
                <ref bean="role1"/>
                <ref bean="role2"/>
            </set>
        </property>
    </bean>
</beans>

命名空间装配

c表示通过构造器，c:_0表示构造器的第一个参数，c:_1表示构造器的第一个参数，其他同理，所以必须在POJO上实现对应参数的构造器
p表示通过引用属性，p:id表示使用setId方法进行设置，其他同理

util表示使用内置的对象进行设置，例如list、set

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="role3" class="com.louris.springboot.IoCImpl.beans.pojo.Role"
          c:_0="3"
          c:_1="role_name_3"
          c:_2="role_note_3"/>
    <bean id="role4" class="com.louris.springboot.IoCImpl.beans.pojo.Role"
          p:id="4"
          p:roleName="role_name_4"
          p:note="role_note_4"/>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <bean id="complexAssembly" class="com.louris.springboot.IoCImpl.beans.pojo.ComplexAssembly">
        <property name="id" value="1"/>
        <property name="list">
            <list>
                <value>value-list-1</value>
                <value>value-list-2</value>
                <value>value-list-3</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="key1" value="value-key-1"/>
                <entry key="key2" value="value-key-2"/>
                <entry key="key3" value="value-key-3"/>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="prop1">value-prop-1</prop>
                <prop key="prop2">value-prop-2</prop>
                <prop key="prop3">value-prop-3</prop>
            </props>
        </property>
        <property name="set">
            <set>
                <value>value-set-1</value>
                <value>value-set-2</value>
                <value>value-set-3</value>
            </set>
        </property>
        <property name="array">
            <array>
                <value>value-array-1</value>
                <value>value-array-2</value>
                <value>value-array-3</value>
            </array>
        </property>
    </bean>

    <bean id="role1" class="com.louris.springboot.IoCImpl.beans.pojo.Role">
        <property name="id" value="1"/>
        <property name="roleName" value="role_name_1"/>
        <property name="note" value="role_note_1"/>
    </bean>

    <bean id="role2" class="com.louris.springboot.IoCImpl.beans.pojo.Role">
        <property name="id" value="2"/>
        <property name="roleName" value="role_name_2"/>
        <property name="note" value="note_note_2"/>
    </bean>

    <bean id="user1" class="com.louris.springboot.IoCImpl.beans.pojo.User">
        <property name="id" value="1"/>
        <property name="userName" value="user_name_1"/>
        <property name="note" value="role_note_1"/>
    </bean>

    <bean id="user2" class="com.louris.springboot.IoCImpl.beans.pojo.User">
        <property name="id" value="2"/>
        <property name="userName" value="user_name_2"/>
        <property name="note" value="role_note_1"/>
    </bean>

    <util:list id="list" >
        <ref bean="role1"/>
        <ref bean="role2"/>
    </util:list>
    <util:map id="map">
        <entry key-ref="role1" value-ref="user1"/>
        <entry key-ref="role2" value-ref="user2"/>
    </util:map>
    <util:set id="set">
        <ref bean="role1"/>
        <ref bean="role2"/>
    </util:set>
    <bean id="userRoleAssembly" class="com.louris.springboot.IoCImpl.beans.pojo.UserRoleAssembly"
          p:id="1"
          p:list-ref="list"
          p:map-ref="map"
          p:set-ref="set"/>
</beans>

通过注解装配Bean

更多的时候会考虑使用注解的方式去装配Bean，可以减少XML的配置，注解功能更为强大，它既能实现XML的功能，也提供了自动装配的功能，采用了自动装配后，程序员所需要做的决断就少了，更加有利于对程序的开发。

在Spring中，它提供了两种方式来让Spring IoC容器发现Bean

组件扫描：通过定义资源的方式，让Spring IoC容器扫描对应的包，从而把Bean装配进来；
自动装配：通过注解定义，使得一些依赖关系可以通过注解完成；

使用@Component装配Bean

注解Bean

package com.louris.springboot.IoCImpl.beans.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component(value = "role") //默认是类的小写字母开头
public class Role {
    @Value("1")
    private Long id;
    @Value("role_name_1")
    private String roleName;
    @Value("role_note_1")
    private String note;
    public Role(){}
    public Role(Long id, String roleName, String note){
        this.id = id;
        this.roleName = roleName;
        this.note = note;
    }

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

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public void setNote(String note) {
        this.note = note;
    }

    public String getRoleName() {
        return roleName;
    }

    public String getNote() {
        return note;
    }

    public Long getId() {
        return id;
    }
}

@ComponentScan配置扫描类

注意，@ComponentScan有两个参数：

basePackages，可以扫描多个包的bean，默认为当前Config类的包；
basePackageClasses，可以扫描多个指定的bean
如果采用多个@ComponentScan去定义对应的包，但是每定义一个@ComponentScan，Spring就会为所定义的类生成一个新的对象，也就是所配置的Bean将会生成多个实例，这往往不是我们需要的；

对于同时一定了上述两个参数的@ComponentScan，Spring会进行专门的区分，也就是说在同一个@ComponentScan中即使重复定义相同的包或者存在其子包定义，也不会造成因同一个Bean的多次扫描，而导致一次配置生成多个对象。

package com.louris.springboot.IoCImpl.config;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import org.springframework.context.annotation.ComponentScan;

//@ComponentScan(basePackages = {"com.louris.springboot.IoCImpl.beans"})
@ComponentScan(basePackageClasses = {Role.class})
public class PojoConfig {

}

测试类

package com.louris.springboot;

import com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker;
import com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker2;
import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.config.PojoConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

//SpringBoot项目启动入口类
@SpringBootApplication  //SpringBoot核心朱姐，主要用于开启spring自动配置
public class Application {

    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(PojoConfig.class);
        Role role = applicationContext.getBean(Role.class);
        System.out.println(role.getRoleName());

    }

}

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=57856:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\SpringBootCourse\001-springboot-first\target\classes;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.4.4\spring-boot-starter-web-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter\2.4.4\spring-boot-starter-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.4.4\spring-boot-autoconfigure-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.4.4\spring-boot-starter-logging-2.4.4.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.13.3\log4j-to-slf4j-2.13.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-api\2.13.3\log4j-api-2.13.3.jar;C:\Users\98383\.m2\repository\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;C:\Users\98383\.m2\repository\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;C:\Users\98383\.m2\repository\org\yaml\snakeyaml\1.27\snakeyaml-1.27.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.4.4\spring-boot-starter-json-2.4.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.11.4\jackson-databind-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.11.4\jackson-annotations-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.11.4\jackson-core-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.11.4\jackson-datatype-jdk8-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.11.4\jackson-datatype-jsr310-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.11.4\jackson-module-parameter-names-2.11.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.4.4\spring-boot-starter-tomcat-2.4.4.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\9.0.44\tomcat-embed-core-9.0.44.jar;C:\Users\98383\.m2\repository\org\glassfish\jakarta.el\3.0.3\jakarta.el-3.0.3.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.44\tomcat-embed-websocket-9.0.44.jar;C:\Users\98383\.m2\repository\org\springframework\spring-web\5.3.5\spring-web-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-webmvc\5.3.5\spring-webmvc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-aop\5.3.5\spring-aop-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-expression\5.3.5\spring-expression-5.3.5.jar;C:\Users\98383\.m2\repository\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\98383\.m2\repository\org\springframework\spring-core\5.3.5\spring-core-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jcl\5.3.5\spring-jcl-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-beans\5.3.5\spring-beans-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot\2.4.4\spring-boot-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-context\5.3.5\spring-context-5.3.5.jar com.louris.springboot.Application
Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  `  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.4)

2021-09-14 17:01:32.447  INFO 12744 --- [           main] com.louris.springboot.Application        : Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 12744 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-14 17:01:32.448  INFO 12744 --- [           main] com.louris.springboot.Application        : No active profile set, falling back to default profiles: default
2021-09-14 17:01:33.050  INFO 12744 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2021-09-14 17:01:33.056  INFO 12744 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-14 17:01:33.057  INFO 12744 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-14 17:01:33.116  INFO 12744 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-14 17:01:33.116  INFO 12744 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 639 ms
2021-09-14 17:01:33.213  INFO 12744 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-09-14 17:01:33.312  INFO 12744 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-09-14 17:01:33.318  INFO 12744 --- [           main] com.louris.springboot.Application        : Started Application in 1.084 seconds (JVM running for 1.455)
role_name_1

自动装配——@Autowired

Spring先完成Bean的定义和生成，然后寻找需要注入的资源；也就是当Spring生成所有的Bean后，如果发现这个注解，它就会在Bean中查找，然后找到对应的类型，将其注入进来，这样就完成了依赖注入了。

自动装配技术是一种由Spring自己发现对应的Bean，自动完成装配工作的方式，它会应用到一个十分常用的注解@Autowired上，这个时候Spring会根据类型去寻找定义的Bean然后将其注入，按类型的方式。

RoleService

package com.louris.springboot.IoCImpl.service;

public interface RoleService {
    void printRoleInfo();
}

RoleServiceImpl

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RoleServiceImpl implements RoleService {

    @Autowired(required = true) //默认true，表示默认一定能找到，否则抛出异常，改成false则允许不注入
    private Role role = null;

    @Override
    public void printRoleInfo() {
        System.out.println("id =" + role.getId());
        System.out.println("roleName =" + role.getRoleName());
        System.out.println("note =" + role.getNote());
    }

    public void setRole(Role role) {
        this.role = role;
    }

    public Role getRole() {
        return role;
    }
}

PojoConfig

package com.louris.springboot.IoCImpl.config;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.impl.RoleServiceImpl;
import org.springframework.context.annotation.ComponentScan;

//@ComponentScan(basePackages = {"com.louris.springboot.IoCImpl.beans"})
//@ComponentScan(basePackageClasses = {Role.class})
@ComponentScan(basePackageClasses = {RoleServiceImpl.class, Role.class})
public class PojoConfig {

}

测试启动类

package com.louris.springboot;

import com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker;
import com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker2;
import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.config.PojoConfig;
import com.louris.springboot.IoCImpl.impl.RoleServiceImpl;
import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

//SpringBoot项目启动入口类
@SpringBootApplication  //SpringBoot核心朱姐，主要用于开启spring自动配置
public class Application {

    @Autowired
    private static Role role = null;
    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);
//        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
////        JuiceMaker juiceMaker = (JuiceMaker) applicationContext.getBean("juiceMaker");
////        System.out.println(juiceMaker.makeJuice());
//        JuiceMaker2 juiceMaker2 = (JuiceMaker2) applicationContext.getBean("juiceMaker2");
//        System.out.println(juiceMaker2.makeJuice());
//
//
//        Role role = (Role)applicationContext.getBean("role");
//        System.out.println(role.getId());
//        System.out.println(role.getNote());
//        System.out.println(role.getRoleName());
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(PojoConfig.class);
//        Role role = applicationContext.getBean(Role.class);
//        System.out.println(role.getRoleName());
//        RoleService role = new RoleServiceImpl();
//        role.printRoleInfo();
        RoleService role = applicationContext.getBean(RoleServiceImpl.class);
        role.printRoleInfo();
    }

}

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=60803:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\SpringBootCourse\001-springboot-first\target\classes;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.4.4\spring-boot-starter-web-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter\2.4.4\spring-boot-starter-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.4.4\spring-boot-autoconfigure-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.4.4\spring-boot-starter-logging-2.4.4.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.13.3\log4j-to-slf4j-2.13.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-api\2.13.3\log4j-api-2.13.3.jar;C:\Users\98383\.m2\repository\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;C:\Users\98383\.m2\repository\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;C:\Users\98383\.m2\repository\org\yaml\snakeyaml\1.27\snakeyaml-1.27.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.4.4\spring-boot-starter-json-2.4.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.11.4\jackson-databind-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.11.4\jackson-annotations-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.11.4\jackson-core-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.11.4\jackson-datatype-jdk8-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.11.4\jackson-datatype-jsr310-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.11.4\jackson-module-parameter-names-2.11.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.4.4\spring-boot-starter-tomcat-2.4.4.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\9.0.44\tomcat-embed-core-9.0.44.jar;C:\Users\98383\.m2\repository\org\glassfish\jakarta.el\3.0.3\jakarta.el-3.0.3.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.44\tomcat-embed-websocket-9.0.44.jar;C:\Users\98383\.m2\repository\org\springframework\spring-web\5.3.5\spring-web-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-webmvc\5.3.5\spring-webmvc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-aop\5.3.5\spring-aop-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-expression\5.3.5\spring-expression-5.3.5.jar;C:\Users\98383\.m2\repository\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\98383\.m2\repository\org\springframework\spring-core\5.3.5\spring-core-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jcl\5.3.5\spring-jcl-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-beans\5.3.5\spring-beans-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot\2.4.4\spring-boot-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-context\5.3.5\spring-context-5.3.5.jar com.louris.springboot.Application
Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  `  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.4)

2021-09-14 21:18:05.341  INFO 23808 --- [           main] com.louris.springboot.Application        : Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 23808 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-14 21:18:05.342  INFO 23808 --- [           main] com.louris.springboot.Application        : No active profile set, falling back to default profiles: default
2021-09-14 21:18:05.992  INFO 23808 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2021-09-14 21:18:05.999  INFO 23808 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-14 21:18:05.999  INFO 23808 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-14 21:18:06.079  INFO 23808 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-14 21:18:06.079  INFO 23808 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 708 ms
2021-09-14 21:18:06.106  INFO 23808 --- [           main] f.a.AutowiredAnnotationBeanPostProcessor : Autowired annotation is not supported on static fields: private static com.louris.springboot.IoCImpl.beans.pojo.Role com.louris.springboot.Application.role
2021-09-14 21:18:06.177  INFO 23808 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-09-14 21:18:06.275  INFO 23808 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-09-14 21:18:06.281  INFO 23808 --- [           main] com.louris.springboot.Application        : Started Application in 1.152 seconds (JVM running for 1.537)
id =1
roleName =role_name_1
note =role_note_1

可以看到，@Autowired自动注入到RoleServiceImpl中，避免了手动获取bean并幅值。

@Autowired方法配置

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RoleServiceImpl implements RoleService {

    //@Autowired(required = true) //默认true，表示默认一定能找到，否则抛出异常，改成false则允许不注入
    private Role role = null;

    @Override
    public void printRoleInfo() {
        System.out.println("id =" + role.getId());
        System.out.println("roleName =" + role.getRoleName());
        System.out.println("note =" + role.getNote());
    }

    @Autowired
    public void setRole(Role role) {
        this.role = role;
    }

    public Role getRole() {
        return role;
    }
}

自动装配的歧义性（@Primary 和 @Qualifier）

例如同一个接口有两个不同的实现类，那么注入的时候会有歧义性。

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RoleServiceImpl implements RoleService {

    //@Autowired(required = true) //默认true，表示默认一定能找到，否则抛出异常，改成false则允许不注入
    private Role role = null;

    @Override
    public void printRoleInfo() {
        System.out.println("id =" + role.getId());
        System.out.println("roleName =" + role.getRoleName());
        System.out.println("note =" + role.getNote());
    }

    @Autowired
    public void setRole(Role role) {
        this.role = role;
    }

    public Role getRole() {
        return role;
    }
}

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

@Component
public class RoleServiceImp2 implements RoleService {

    @Autowired
    private Role role = null;

    @Override
    public void printRoleInfo() {
        System.out.println("Impl2");
        System.out.println("id =" + role.getId());
        System.out.println("roleName =" + role.getRoleName());
        System.out.println("note =" + role.getNote());
    }
}

package com.louris.springboot.IoCImpl.controller;

import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RoleController {
    @Autowired
    private RoleService roleService = null;

    public void printRole(){
        roleService.printRoleInfo();
    }
}

@Primary

通过该注解让Spring优先将被注解的类注入，消除歧义性

实现

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

@Component
@Primary
public class RoleServiceImp2 implements RoleService {

    @Autowired
    private Role role = null;

    @Override
    public void printRoleInfo() {
        System.out.println("Impl2");
        System.out.println("id =" + role.getId());
        System.out.println("roleName =" + role.getRoleName());
        System.out.println("note =" + role.getNote());
    }
}

package com.louris.springboot.IoCImpl.config;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.impl.RoleServiceImpl;
import org.springframework.context.annotation.ComponentScan;

//@ComponentScan(basePackages = {"com.louris.springboot.IoCImpl.beans"})
//@ComponentScan(basePackageClasses = {Role.class})
//@ComponentScan(basePackageClasses = {RoleServiceImpl.class, Role.class})
@ComponentScan(basePackages = {"com.louris.springboot.IoCImpl.beans",
        "com.louris.springboot.IoCImpl.controller",
        "com.louris.springboot.IoCImpl.impl"})
public class PojoConfig {

}

package com.louris.springboot;

import com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker;
import com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker2;
import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.config.PojoConfig;
import com.louris.springboot.IoCImpl.controller.RoleController;
import com.louris.springboot.IoCImpl.impl.RoleServiceImpl;
import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

//SpringBoot项目启动入口类
@SpringBootApplication  //SpringBoot核心朱姐，主要用于开启spring自动配置
public class Application {

    @Autowired
    private static Role role = null;
    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(PojoConfig.class);
        RoleController roleController = applicationContext.getBean(RoleController.class);
        roleController.printRole();
    }

}

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=54761:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\SpringBootCourse\001-springboot-first\target\classes;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.4.4\spring-boot-starter-web-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter\2.4.4\spring-boot-starter-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.4.4\spring-boot-autoconfigure-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.4.4\spring-boot-starter-logging-2.4.4.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.13.3\log4j-to-slf4j-2.13.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-api\2.13.3\log4j-api-2.13.3.jar;C:\Users\98383\.m2\repository\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;C:\Users\98383\.m2\repository\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;C:\Users\98383\.m2\repository\org\yaml\snakeyaml\1.27\snakeyaml-1.27.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.4.4\spring-boot-starter-json-2.4.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.11.4\jackson-databind-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.11.4\jackson-annotations-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.11.4\jackson-core-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.11.4\jackson-datatype-jdk8-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.11.4\jackson-datatype-jsr310-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.11.4\jackson-module-parameter-names-2.11.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.4.4\spring-boot-starter-tomcat-2.4.4.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\9.0.44\tomcat-embed-core-9.0.44.jar;C:\Users\98383\.m2\repository\org\glassfish\jakarta.el\3.0.3\jakarta.el-3.0.3.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.44\tomcat-embed-websocket-9.0.44.jar;C:\Users\98383\.m2\repository\org\springframework\spring-web\5.3.5\spring-web-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-webmvc\5.3.5\spring-webmvc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-aop\5.3.5\spring-aop-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-expression\5.3.5\spring-expression-5.3.5.jar;C:\Users\98383\.m2\repository\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\98383\.m2\repository\org\springframework\spring-core\5.3.5\spring-core-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jcl\5.3.5\spring-jcl-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-beans\5.3.5\spring-beans-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot\2.4.4\spring-boot-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-context\5.3.5\spring-context-5.3.5.jar com.louris.springboot.Application
Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  `  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.4)

2021-09-14 21:52:52.498  INFO 7232 --- [           main] com.louris.springboot.Application        : Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 7232 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-14 21:52:52.499  INFO 7232 --- [           main] com.louris.springboot.Application        : No active profile set, falling back to default profiles: default
2021-09-14 21:52:53.087  INFO 7232 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2021-09-14 21:52:53.099  INFO 7232 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-14 21:52:53.099  INFO 7232 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-14 21:52:53.165  INFO 7232 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-14 21:52:53.165  INFO 7232 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 618 ms
2021-09-14 21:52:53.191  INFO 7232 --- [           main] f.a.AutowiredAnnotationBeanPostProcessor : Autowired annotation is not supported on static fields: private static com.louris.springboot.IoCImpl.beans.pojo.Role com.louris.springboot.Application.role
2021-09-14 21:52:53.266  INFO 7232 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-09-14 21:52:53.358  INFO 7232 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-09-14 21:52:53.364  INFO 7232 --- [           main] com.louris.springboot.Application        : Started Application in 1.083 seconds (JVM running for 1.451)
Impl2
id =1
roleName =role_name_1
note =role_note_1

@Qualifier

上面出现的歧义性，重要原因是SPring采用@Autowired是按照type进行注入的，那么如果采用名称查找的方式就可以消除歧义性了，故可以使用@Qualifier注解。

package com.louris.springboot.IoCImpl.controller;

import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
public class RoleController {
    @Autowired
    @Qualifier(value = "roleServiceImpl")
    private RoleService roleService = null;

    public void printRole(){
        roleService.printRoleInfo();
    }
}

该注解设计IoC容器的底层接口——BeanFactory

1	Object getBean(String name) throws BeansException;

装载带有参数的构造方法类

@Autowired和@Qualifer可以注解到参数

package com.louris.springboot.IoCImpl.controller;

import com.louris.springboot.IoCImpl.impl.RoleServiceImp2;
import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
public class RoleController2 {
    private RoleService roleService = null;
//
//    public RoleController2(@Autowired RoleService roleService){
//        this.roleService = roleService;
//    }

    public RoleController2(@Qualifier("roleServiceImpl") RoleService roleService){
        this.roleService = roleService;
    }

    public void printRole(){
        roleService.printRoleInfo();
    }
}

使用@Bean装配Bean

以上都是通过@Component装配Bean，但是@Component只能注解在类上，不能注解到方法上。而对于Java而言，大部分的开发都需要引入第三方的包，而且往往并没有这些包的源码，这时候将无法为这些包的类加入@Component注解，让它们变为开发环境的Bean。

@Bean可以注解到方法之上，并且将方法返回的对象作为Spring的Bean，存放在IoC容器中。

@Bean(name = "dataSource")
public DataSource getDataSource(){
    Properties properties = new Properties();
    properties.setProperty("driver", "com.mysql.jdbc.Driver");
    properties.setProperty("url", "jdbc:mysql://localhost:3306/chapter12");
    properties.setProperty("username", "root");
    properties.setProperty("password", "123456");
    DataSource dataSource = null;
    try{
        dataSource = BasicDataSourceFactory.createDataSource(properties);
    }catch (Exception e){
        e.printStackTrace();
    }
    return dataSource;
}

注解自定义Bean的初始化和销毁方法

@Bean的配置项：

name：是一个字符串数组，允许配置多个BeanName
autowire：标志是否是一个引用的Bean对象，默认值是Autowire.NO
initMethod：自定义初始化方法
destroyMethod：自定义销毁方法

@Bean(name = "juiceMaker2", initMethod = "init", destroyMethod = "destroy")
public JuiceMaker2 initJuiceMaker(){
    JuiceMaker2 juiceMaker2 = new JuiceMaker2();
    juiceMaker2.setBeverageShop("贡茶");
    Source source = new Source();
    source.setFruit("橙子");
    source.setSize(2);
    source.setSugar("少糖");
    juiceMaker2.setSource(source);
    juiceMaker2.makeJuice();
    return juiceMaker2;
}

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=54328:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\SpringBootCourse\001-springboot-first\target\classes;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.4.4\spring-boot-starter-web-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter\2.4.4\spring-boot-starter-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.4.4\spring-boot-autoconfigure-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.4.4\spring-boot-starter-logging-2.4.4.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.13.3\log4j-to-slf4j-2.13.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-api\2.13.3\log4j-api-2.13.3.jar;C:\Users\98383\.m2\repository\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;C:\Users\98383\.m2\repository\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;C:\Users\98383\.m2\repository\org\yaml\snakeyaml\1.27\snakeyaml-1.27.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.4.4\spring-boot-starter-json-2.4.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.11.4\jackson-databind-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.11.4\jackson-annotations-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.11.4\jackson-core-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.11.4\jackson-datatype-jdk8-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.11.4\jackson-datatype-jsr310-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.11.4\jackson-module-parameter-names-2.11.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.4.4\spring-boot-starter-tomcat-2.4.4.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\9.0.44\tomcat-embed-core-9.0.44.jar;C:\Users\98383\.m2\repository\org\glassfish\jakarta.el\3.0.3\jakarta.el-3.0.3.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.44\tomcat-embed-websocket-9.0.44.jar;C:\Users\98383\.m2\repository\org\springframework\spring-web\5.3.5\spring-web-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-webmvc\5.3.5\spring-webmvc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-aop\5.3.5\spring-aop-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-expression\5.3.5\spring-expression-5.3.5.jar;C:\Users\98383\.m2\repository\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\98383\.m2\repository\org\springframework\spring-core\5.3.5\spring-core-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jcl\5.3.5\spring-jcl-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-beans\5.3.5\spring-beans-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot\2.4.4\spring-boot-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-context\5.3.5\spring-context-5.3.5.jar com.louris.springboot.Application
Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  `  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.4)

2021-09-15 10:51:54.224  INFO 12836 --- [           main] com.louris.springboot.Application        : Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 12836 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-15 10:51:54.226  INFO 12836 --- [           main] com.louris.springboot.Application        : No active profile set, falling back to default profiles: default
2021-09-15 10:51:54.851  INFO 12836 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2021-09-15 10:51:54.858  INFO 12836 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-15 10:51:54.858  INFO 12836 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-15 10:51:54.918  INFO 12836 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-15 10:51:54.918  INFO 12836 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 658 ms
2021-09-15 10:51:54.947  INFO 12836 --- [           main] f.a.AutowiredAnnotationBeanPostProcessor : Autowired annotation is not supported on static fields: private static com.louris.springboot.IoCImpl.beans.pojo.Role com.louris.springboot.Application.role
【JuiceMaker2】调用BeanNameAware接口的setBeanName方法
【JuiceMaker2】调用BeanFactoryAware接口的setBeanFactory方法
【JuiceMaker2】调用ApplicationContextAware接口的setApplicationContext方法
【JuiceMaker2】调用Initializing接口的afterPropertiesSet方法
【JuiceMaker2】执行自定义初始化方法
2021-09-15 10:51:55.030  INFO 12836 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-09-15 10:51:55.133  INFO 12836 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-09-15 10:51:55.139  INFO 12836 --- [           main] com.louris.springboot.Application        : Started Application in 1.126 seconds (JVM running for 1.501)

装配的混合使用

一般本项目中的类通过注解注入，而外部包的类则通过XML进行bean注入。

实例

package com.louris.springboot.IoCImpl.service;

import com.louris.springboot.IoCImpl.beans.pojo.Role;

public interface RoleDataSourceService {
    Role getRole(Long id);
}

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.service.RoleDataSourceService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.ScopedProxyMode;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

@Component
public class RoleDataSourceServiceImpl implements RoleDataSourceService {

    @Autowired
    private final DataSource dataSource = null;

    @Override
    public Role getRole(Long id) {
        Connection connection = null;
        ResultSet resultSet = null;
        PreparedStatement preparedStatement = null;
        Role role = null;
        try{
            connection = dataSource.getConnection();
            preparedStatement = connection.prepareStatement("select id, role_name, note from t_role where id = ?");
            preparedStatement.setLong(1, id);
            resultSet = preparedStatement.executeQuery();
            while(resultSet.next()){
                role = new Role();
                role.setId(resultSet.getLong("id"));
                role.setRoleName(resultSet.getString("role_name"));
                role.setNote(resultSet.getString("note"));
            }
        }catch (SQLException e){
            e.printStackTrace();
        }finally {
            try{
                if(connection != null) connection.close();
            }catch (SQLException e){
                e.printStackTrace();
            }
        }
        return role;
    }
}

package com.louris.springboot.IoCImpl.config;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.impl.RoleServiceImpl;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ImportResource;

//@ComponentScan(basePackages = {"com.louris.springboot.IoCImpl.beans"})
//@ComponentScan(basePackageClasses = {Role.class})
//@ComponentScan(basePackageClasses = {RoleServiceImpl.class, Role.class})
@ComponentScan(basePackages = {"com.louris.springboot.IoCImpl.beans",
        "com.louris.springboot.IoCImpl.controller",
        "com.louris.springboot.IoCImpl.impl"})
@ImportResource(locations = "classpath:spring-dataSource.xml")
public class PojoConfig {

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
</beans>

<!-- dbcp数据源 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-dbcp2</artifactId>
</dependency>
<!-- mysql驱动包 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

package com.louris.springboot;

import com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker;
import com.louris.springboot.IoCImpl.beans.pojo.JuiceMaker2;
import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.beans.pojo.Source;
import com.louris.springboot.IoCImpl.config.PojoConfig;
import com.louris.springboot.IoCImpl.controller.RoleController;
import com.louris.springboot.IoCImpl.controller.RoleController2;
import com.louris.springboot.IoCImpl.impl.RoleDataSourceServiceImpl;
import com.louris.springboot.IoCImpl.impl.RoleServiceImpl;
import com.louris.springboot.IoCImpl.service.RoleDataSourceService;
import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.sql.DataSource;
import java.util.Properties;

//SpringBoot项目启动入口类
@SpringBootApplication  //SpringBoot核心朱姐，主要用于开启spring自动配置
//@ImportResource(locations = "classpath:spring-dataSource.xml")
@Import(value = {PojoConfig.class})
public class Application {

    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);

        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(PojoConfig.class);

        RoleDataSourceService roleDataSourceService = applicationContext.getBean(RoleDataSourceServiceImpl.class);
        Role role = roleDataSourceService.getRole(1L);
        System.out.println(role.getRoleName());
    }
}

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=53592:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\SpringBootCourse\001-springboot-first\target\classes;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.4.4\spring-boot-starter-web-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter\2.4.4\spring-boot-starter-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.4.4\spring-boot-autoconfigure-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.4.4\spring-boot-starter-logging-2.4.4.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.13.3\log4j-to-slf4j-2.13.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-api\2.13.3\log4j-api-2.13.3.jar;C:\Users\98383\.m2\repository\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;C:\Users\98383\.m2\repository\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;C:\Users\98383\.m2\repository\org\yaml\snakeyaml\1.27\snakeyaml-1.27.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.4.4\spring-boot-starter-json-2.4.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.11.4\jackson-databind-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.11.4\jackson-annotations-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.11.4\jackson-core-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.11.4\jackson-datatype-jdk8-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.11.4\jackson-datatype-jsr310-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.11.4\jackson-module-parameter-names-2.11.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.4.4\spring-boot-starter-tomcat-2.4.4.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\9.0.44\tomcat-embed-core-9.0.44.jar;C:\Users\98383\.m2\repository\org\glassfish\jakarta.el\3.0.3\jakarta.el-3.0.3.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.44\tomcat-embed-websocket-9.0.44.jar;C:\Users\98383\.m2\repository\org\springframework\spring-web\5.3.5\spring-web-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-webmvc\5.3.5\spring-webmvc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-aop\5.3.5\spring-aop-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-expression\5.3.5\spring-expression-5.3.5.jar;C:\Users\98383\.m2\repository\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\98383\.m2\repository\org\springframework\spring-core\5.3.5\spring-core-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jcl\5.3.5\spring-jcl-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-beans\5.3.5\spring-beans-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot\2.4.4\spring-boot-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-context\5.3.5\spring-context-5.3.5.jar;C:\Users\98383\.m2\repository\org\apache\commons\commons-dbcp2\2.8.0\commons-dbcp2-2.8.0.jar;C:\Users\98383\.m2\repository\org\apache\commons\commons-pool2\2.9.0\commons-pool2-2.9.0.jar;C:\Users\98383\.m2\repository\mysql\mysql-connector-java\8.0.23\mysql-connector-java-8.0.23.jar;C:\Users\98383\.m2\repository\com\sun\activation\jakarta.activation\1.2.2\jakarta.activation-1.2.2.jar com.louris.springboot.Application
Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  `  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.4)

2021-09-15 16:03:40.011  INFO 28368 --- [           main] com.louris.springboot.Application        : Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 28368 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-15 16:03:40.014  INFO 28368 --- [           main] com.louris.springboot.Application        : No active profile set, falling back to default profiles: default
2021-09-15 16:03:40.706  INFO 28368 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2021-09-15 16:03:40.712  INFO 28368 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-15 16:03:40.712  INFO 28368 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-15 16:03:41.829  INFO 28368 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-15 16:03:41.829  INFO 28368 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 1774 ms
【JuiceMaker2】调用BeanNameAware接口的setBeanName方法
【JuiceMaker2】调用BeanFactoryAware接口的setBeanFactory方法
【JuiceMaker2】调用ApplicationContextAware接口的setApplicationContext方法
【JuiceMaker2】调用Initializing接口的afterPropertiesSet方法
【JuiceMaker2】执行自定义初始化方法
2021-09-15 16:03:41.953  INFO 28368 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-09-15 16:03:42.051  INFO 28368 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-09-15 16:03:42.058  INFO 28368 --- [           main] com.louris.springboot.Application        : Started Application in 2.298 seconds (JVM running for 2.714)
John

加载多个配置文件

@ComponentScan(basePackages = {"com.louris.springboot.IoCImpl.beans",
        "com.louris.springboot.IoCImpl.controller",
        "com.louris.springboot.IoCImpl.impl"})
@ImportResource(locations = "classpath:spring-dataSource.xml")
@Import({Config1.class, Config2.class})
public class PojoConfig {

}

有多个XML配置文件，希望通过其中一个XML文件引入其他的XML文件

1	<import resource="spring-dataSource.xml"/>

或通过context:component-scan替换注解@Component

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <context:component-scan base-package="com.louris.springboot.IoCImpl.beans"/>

使用Profile

在软件开发过程中，可能开发人员使用一套环境，而测试人员能使用另一套环境，而这两台系统的数据库是不一样的，毕竟测试人员也需要花费很多时间去构建测试数据，可不想老是被开发人员修改那些测试数据，这样就有了在不同环境中进行切换的需求了。

使用注解@Profile配置

配置两个数据库连接池，一个用于开发（dev），一个用于测试（test）。

package com.louris.springboot.IoCImpl.profile;

import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.util.Properties;

@Component
public class ProfileDataSource {

    @Bean(name="devDataSource")
    @Profile(value = "dev")
    public DataSource getDevDataSource(){
        Properties properties = new Properties();
        properties.setProperty("driver", "com.mysql.cj.jdbc.Driver");
        properties.setProperty("url", "jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC");
        properties.setProperty("username", "root");
        properties.setProperty("password", "123456");
        DataSource dataSource = null;
        try{
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        }catch (Exception e){
            e.printStackTrace();
        }
        return dataSource;
    }

    @Bean(name="testDataSource")
    @Profile(value = "test")
    public DataSource getTestDataSource(){
        Properties properties = new Properties();
        properties.setProperty("driver", "com.mysql.cj.jdbc.Driver");
        properties.setProperty("url", "jdbc:mysql://localhost:3306/ssm_test?serverTimezone=UTC");
        properties.setProperty("username", "root");
        properties.setProperty("password", "123456");
        DataSource dataSource = null;
        try{
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        }catch (Exception e){
            e.printStackTrace();
        }
        return dataSource;
    }
}

使用XML定义Profile

(1)配置文件的profile属性

该属性会导致一个配置文件所有的Bean都放在dev的Profile下；

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
       profile="dev">
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
</beans>

(2)配置文件的beans元素的profile属性

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <beans profile="dev">
        <bean id="devDataSource" class="org.apache.commons.dbcp2.BasicDataSource">
            <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
        </bean>
    </beans>

    <beans profile="test">
        <bean id="testDataSource" class="org.apache.commons.dbcp2.BasicDataSource">
            <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/ssm_test?serverTimezone=UTC"/>
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
        </bean>
    </beans>
</beans>

启动Profile

application.properties核心配置文件
application-dev.properties开发环境核心配置文件
application-test.properties测试环境核心配置文件

1	spring.profiles.active=dev

package com.louris.springboot.IoCImpl.profile;

import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
@PropertySource(value = "classpath:application.properties")
public class ProfileDataSource {

    @Bean(name = "dataSource")
    @Profile(value = "dev")
    public DataSource getDevDataSource(){
        Properties properties = new Properties();
        properties.setProperty("driverClassName", "com.mysql.cj.jdbc.Driver");
        properties.setProperty("url", "jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC");
        properties.setProperty("username", "root");
        properties.setProperty("password", "123456");
        DataSource dataSource = null;
        try{
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        }catch (Exception e){
            e.printStackTrace();
        }
        return dataSource;
    }

    @Bean(name="dataSource")
    @Profile("test")
    public DataSource getTestDataSource(){
        Properties properties = new Properties();
        properties.setProperty("driver", "com.mysql.cj.jdbc.Driver");
        properties.setProperty("url", "jdbc:mysql://localhost:3306/ssm_test?serverTimezone=UTC");
        properties.setProperty("username", "root");
        properties.setProperty("password", "123456");
        DataSource dataSource = null;
        try{
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        }catch (Exception e){
            e.printStackTrace();
        }
        return dataSource;
    }
}

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=65000:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\SpringBootCourse\001-springboot-first\target\classes;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.4.4\spring-boot-starter-web-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter\2.4.4\spring-boot-starter-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.4.4\spring-boot-autoconfigure-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.4.4\spring-boot-starter-logging-2.4.4.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.13.3\log4j-to-slf4j-2.13.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-api\2.13.3\log4j-api-2.13.3.jar;C:\Users\98383\.m2\repository\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;C:\Users\98383\.m2\repository\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;C:\Users\98383\.m2\repository\org\yaml\snakeyaml\1.27\snakeyaml-1.27.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.4.4\spring-boot-starter-json-2.4.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.11.4\jackson-databind-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.11.4\jackson-annotations-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.11.4\jackson-core-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.11.4\jackson-datatype-jdk8-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.11.4\jackson-datatype-jsr310-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.11.4\jackson-module-parameter-names-2.11.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.4.4\spring-boot-starter-tomcat-2.4.4.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\9.0.44\tomcat-embed-core-9.0.44.jar;C:\Users\98383\.m2\repository\org\glassfish\jakarta.el\3.0.3\jakarta.el-3.0.3.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.44\tomcat-embed-websocket-9.0.44.jar;C:\Users\98383\.m2\repository\org\springframework\spring-web\5.3.5\spring-web-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-webmvc\5.3.5\spring-webmvc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-aop\5.3.5\spring-aop-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-expression\5.3.5\spring-expression-5.3.5.jar;C:\Users\98383\.m2\repository\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\98383\.m2\repository\org\springframework\spring-core\5.3.5\spring-core-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jcl\5.3.5\spring-jcl-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-beans\5.3.5\spring-beans-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot\2.4.4\spring-boot-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-context\5.3.5\spring-context-5.3.5.jar;C:\Users\98383\.m2\repository\org\apache\commons\commons-dbcp2\2.8.0\commons-dbcp2-2.8.0.jar;C:\Users\98383\.m2\repository\org\apache\commons\commons-pool2\2.9.0\commons-pool2-2.9.0.jar;C:\Users\98383\.m2\repository\mysql\mysql-connector-java\8.0.23\mysql-connector-java-8.0.23.jar;C:\Users\98383\.m2\repository\com\sun\activation\jakarta.activation\1.2.2\jakarta.activation-1.2.2.jar com.louris.springboot.Application
Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  `  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.4)

2021-09-15 22:49:14.825  INFO 21616 --- [           main] com.louris.springboot.Application        : Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 21616 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-15 22:49:14.826  INFO 21616 --- [           main] com.louris.springboot.Application        : The following profiles are active: dev
2021-09-15 22:49:15.675  INFO 21616 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2021-09-15 22:49:15.681  INFO 21616 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-15 22:49:15.681  INFO 21616 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-15 22:49:15.752  INFO 21616 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-15 22:49:15.752  INFO 21616 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 891 ms
2021-09-15 22:49:15.887  INFO 21616 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-09-15 22:49:15.995  INFO 21616 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-09-15 22:49:16.002  INFO 21616 --- [           main] com.louris.springboot.Application        : Started Application in 1.402 seconds (JVM running for 1.773)
John

获取ApplicationContext

自定义新建ApplicationContext

加载XML配置文件方式

1
2
3

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
Role role = (Role)applicationContext.getBean("role");
Role role1 = applicationContext.getBean(Role.class);

加载注解配置类方式

@ComponentScan(basePackages = {"com.louris.springboot.IoCImpl.beans"})
//@ComponentScan(basePackageClasses = {Role.class})
//@ComponentScan(basePackageClasses = {RoleServiceImpl.class, Role.class})
@Configuration  //配置类
@ComponentScan(basePackages = {"com.louris.springboot.IoCImpl"}) //扫描包下的Beans
//@ImportResource(locations = "classpath:spring-dataSource.xml") //引入资源配置文件
@PropertySource(value = "classpath:application.properties", ignoreResourceNotFound = false) //引入配置文件
public class PojoConfig {

}

1
2
3

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(PojoConfig.class);
Role role = (Role)applicationContext.getBean("role");
Role role1 = applicationContext.getBean(Role.class);

启动类方式

1
2
3

ApplicationContext applicationContext = SpringApplication.run(Application.class, args);
Role role = (Role)applicationContext.getBean("role");
Role role1 = applicationContext.getBean(Role.class);

加载属性（properties）文件

server.port=8081
# 设置连接数据库的信息
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123456

spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource
spring.datasource.dbcp2.max-idle=10
spring.datasource.dbcp2.max-total=50
spring.datasource.dbcp2.max-wait-millis=10000

使用注解方式加载属性文件

@PropertySource注解

name: 字符串，配置这次属性配置的名称
value：字符串数组，可以配置多个属性文件

ignoreResourceNotFound：默认false，找不到对应配置文件会抛出异常

1
2
3

@Configuration
@PropertySource(value = "classpath:application.properties", ignoreResourceNotFound = false)
public class ProfileDataSource {}

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(PojoConfig.class);

String url = applicationContext.getEnvironment().getProperty("spring.datasource.url");
System.out.println(url);

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=62587:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\SpringBootCourse\001-springboot-first\target\classes;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.4.4\spring-boot-starter-web-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter\2.4.4\spring-boot-starter-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.4.4\spring-boot-autoconfigure-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.4.4\spring-boot-starter-logging-2.4.4.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.13.3\log4j-to-slf4j-2.13.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-api\2.13.3\log4j-api-2.13.3.jar;C:\Users\98383\.m2\repository\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;C:\Users\98383\.m2\repository\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;C:\Users\98383\.m2\repository\org\yaml\snakeyaml\1.27\snakeyaml-1.27.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.4.4\spring-boot-starter-json-2.4.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.11.4\jackson-databind-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.11.4\jackson-annotations-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.11.4\jackson-core-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.11.4\jackson-datatype-jdk8-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.11.4\jackson-datatype-jsr310-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.11.4\jackson-module-parameter-names-2.11.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.4.4\spring-boot-starter-tomcat-2.4.4.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\9.0.44\tomcat-embed-core-9.0.44.jar;C:\Users\98383\.m2\repository\org\glassfish\jakarta.el\3.0.3\jakarta.el-3.0.3.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.44\tomcat-embed-websocket-9.0.44.jar;C:\Users\98383\.m2\repository\org\springframework\spring-web\5.3.5\spring-web-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-webmvc\5.3.5\spring-webmvc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-aop\5.3.5\spring-aop-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-expression\5.3.5\spring-expression-5.3.5.jar;C:\Users\98383\.m2\repository\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\98383\.m2\repository\org\springframework\spring-core\5.3.5\spring-core-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jcl\5.3.5\spring-jcl-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-beans\5.3.5\spring-beans-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot\2.4.4\spring-boot-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-context\5.3.5\spring-context-5.3.5.jar;C:\Users\98383\.m2\repository\org\apache\commons\commons-dbcp2\2.8.0\commons-dbcp2-2.8.0.jar;C:\Users\98383\.m2\repository\org\apache\commons\commons-pool2\2.9.0\commons-pool2-2.9.0.jar;C:\Users\98383\.m2\repository\mysql\mysql-connector-java\8.0.23\mysql-connector-java-8.0.23.jar;C:\Users\98383\.m2\repository\com\sun\activation\jakarta.activation\1.2.2\jakarta.activation-1.2.2.jar com.louris.springboot.Application
Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  `  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.4)

2021-09-16 10:17:18.644  INFO 27900 --- [           main] com.louris.springboot.Application        : Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 27900 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-16 10:17:18.646  INFO 27900 --- [           main] com.louris.springboot.Application        : No active profile set, falling back to default profiles: default
2021-09-16 10:17:19.280  INFO 27900 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8081 (http)
2021-09-16 10:17:19.286  INFO 27900 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-16 10:17:19.286  INFO 27900 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-16 10:17:19.350  INFO 27900 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-16 10:17:19.350  INFO 27900 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 676 ms
2021-09-16 10:17:19.449  INFO 27900 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-09-16 10:17:19.548  INFO 27900 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8081 (http) with context path ''
2021-09-16 10:17:19.555  INFO 27900 --- [           main] com.louris.springboot.Application        : Started Application in 1.126 seconds (JVM running for 1.504)
jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8

@PropertySourcesPlaceholderConfigure + @Value注解

package com.louris.springboot.IoCImpl.config;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.impl.RoleServiceImpl;
import org.springframework.context.annotation.*;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

//@ComponentScan(basePackages = {"com.louris.springboot.IoCImpl.beans"})
//@ComponentScan(basePackageClasses = {Role.class})
//@ComponentScan(basePackageClasses = {RoleServiceImpl.class, Role.class})
@Configuration
@ComponentScan(basePackages = {"com.louris.springboot.IoCImpl"})
//@ImportResource(locations = "classpath:spring-dataSource.xml")
@PropertySource(value = "classpath:application-dev.properties", ignoreResourceNotFound = false)
public class PojoConfig {
    @Bean
    public PropertySourcesPlaceholderConfigurer getPropertySourcesPlaceholderConfigurer(){
        return new PropertySourcesPlaceholderConfigurer();
    }
}

package com.louris.springboot.IoCImpl.profile;

import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
//@Profile(value = "dev")
public class ProfileDataSource {

    @Value("${spring.datasource.driver-class-name}")
    private String driver = null;

    @Value("${spring.datasource.url}")
    private String url = null;

    @Value("${spring.datasource.username}")
    private String username = null;

    @Value("${spring.datasource.password}")
    private String password = null;

    @Bean(name = "dataSource")
    public DataSource getDataSource(){
         Properties properties = new Properties();
         properties.setProperty("driver", driver);
         properties.setProperty("usrl", url);
         properties.setProperty("username", username);
         properties.setProperty("password", password);
         DataSource dataSource = null;
         try{
             dataSource = BasicDataSourceFactory.createDataSource(properties);
         }catch (Exception e){
             e.printStackTrace();
         }
         return dataSource;
    }

}

使用XML方式加载属性文件

略过。

条件化装配Bean

比如根据属性文件中的数据源信息进行装配Bean，如果属性不完整，则会创建失败。

自定义条件类

package com.louris.springboot.IoCImpl.config;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class DataSourceCondition implements Condition {

    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //获取上下文环境
        Environment environment = conditionContext.getEnvironment();
        //判断是否存在关于数据源的基础配置
        return environment.containsProperty("spring.datasource.driver")
                && environment.containsProperty("spring.datasource.url")
                && environment.containsProperty("spring.datasource.username")
                && environment.containsProperty("spring.datasource.password");
    }
}

@Conditional注解

package com.louris.springboot.IoCImpl.profile;

import com.louris.springboot.IoCImpl.config.DataSourceCondition;
import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
public class ProfileDataSource {

    @Value("${spring.datasource.driver}")
    private String driver = null;

    @Value("${spring.datasource.url}")
    private String url = null;

    @Value("${spring.datasource.username}")
    private String username = null;

    @Value("${spring.datasource.password}")
    private String password = null;

    @Bean(name = "dataSource")
    @Conditional(value = {DataSourceCondition.class})
    public DataSource getDataSource(){
         Properties properties = new Properties();
         properties.setProperty("driver", driver);
         properties.setProperty("url", url);
         properties.setProperty("username", username);
         properties.setProperty("password", password);
         System.out.println(properties.getProperty("username"));
         DataSource dataSource = null;
         try{
             dataSource = BasicDataSourceFactory.createDataSource(properties);
         }catch (Exception e){
             e.printStackTrace();
         }
         return dataSource;
    }

}

Bean的作用域

单例（singleton）：它是默认的选项，在整个应用中，Spring只为其生成一个Bean的实例；
原型（prototype）：当每次注入，或者通过Spring IoC容器获取Bean时，Spring都会为它创建一个新的实例；
会话（session）：在Web应用中使用，就是在会话过程中Spring只创建一个实例；
请求（request）：在Web应用中使用，就是一个请求中Spring会创建一个实例；

package com.louris.springboot.IoCImpl.beans.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component(value = "role")
@Scope(value = "prototype")
public class Role {
    @Value("1")
    private Long id;
    @Value("role_name_1")
    private String roleName;
    @Value("role_note_1")
    private String note;
    public Role(){}
    public Role(Long id, String roleName, String note){
        this.id = id;
        this.roleName = roleName;
        this.note = note;
    }

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

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public void setNote(String note) {
        this.note = note;
    }

    public String getRoleName() {
        return roleName;
    }

    public String getNote() {
        return note;
    }

    public Long getId() {
        return id;
    }
}

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(PojoConfig.class);
Role role = applicationContext.getBean(Role.class);
Role role1 = applicationContext.getBean(Role.class);
System.out.println(role == role1);

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=59884:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\SpringBootCourse\001-springboot-first\target\classes;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.4.4\spring-boot-starter-web-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter\2.4.4\spring-boot-starter-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.4.4\spring-boot-autoconfigure-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.4.4\spring-boot-starter-logging-2.4.4.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.13.3\log4j-to-slf4j-2.13.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-api\2.13.3\log4j-api-2.13.3.jar;C:\Users\98383\.m2\repository\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;C:\Users\98383\.m2\repository\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;C:\Users\98383\.m2\repository\org\yaml\snakeyaml\1.27\snakeyaml-1.27.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.4.4\spring-boot-starter-json-2.4.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.11.4\jackson-databind-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.11.4\jackson-annotations-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.11.4\jackson-core-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.11.4\jackson-datatype-jdk8-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.11.4\jackson-datatype-jsr310-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.11.4\jackson-module-parameter-names-2.11.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.4.4\spring-boot-starter-tomcat-2.4.4.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\9.0.44\tomcat-embed-core-9.0.44.jar;C:\Users\98383\.m2\repository\org\glassfish\jakarta.el\3.0.3\jakarta.el-3.0.3.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.44\tomcat-embed-websocket-9.0.44.jar;C:\Users\98383\.m2\repository\org\springframework\spring-web\5.3.5\spring-web-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-webmvc\5.3.5\spring-webmvc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-aop\5.3.5\spring-aop-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-expression\5.3.5\spring-expression-5.3.5.jar;C:\Users\98383\.m2\repository\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\98383\.m2\repository\org\springframework\spring-core\5.3.5\spring-core-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jcl\5.3.5\spring-jcl-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-beans\5.3.5\spring-beans-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot\2.4.4\spring-boot-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-context\5.3.5\spring-context-5.3.5.jar;C:\Users\98383\.m2\repository\org\apache\commons\commons-dbcp2\2.8.0\commons-dbcp2-2.8.0.jar;C:\Users\98383\.m2\repository\org\apache\commons\commons-pool2\2.9.0\commons-pool2-2.9.0.jar;C:\Users\98383\.m2\repository\mysql\mysql-connector-java\8.0.23\mysql-connector-java-8.0.23.jar;C:\Users\98383\.m2\repository\com\sun\activation\jakarta.activation\1.2.2\jakarta.activation-1.2.2.jar com.louris.springboot.Application
Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  ·  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.4)

2021-09-16 21:42:21.885  INFO 21908 --- [           main] com.louris.springboot.Application        : Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 21908 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-16 21:42:21.887  INFO 21908 --- [           main] com.louris.springboot.Application        : No active profile set, falling back to default profiles: default
2021-09-16 21:42:22.297  INFO 21908 --- [           main] o.s.c.a.ConfigurationClassEnhancer       : @Bean method PojoConfig.getPropertySourcesPlaceholderConfigurer is non-static and returns an object assignable to Spring's BeanFactoryPostProcessor interface. This will result in a failure to process annotations such as @Autowired, @Resource and @PostConstruct within the method's declaring @Configuration class. Add the 'static' modifier to this method to avoid these container lifecycle issues; see @Bean javadoc for complete details.
2021-09-16 21:42:22.485  INFO 21908 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8081 (http)
2021-09-16 21:42:22.492  INFO 21908 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-16 21:42:22.493  INFO 21908 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-16 21:42:22.556  INFO 21908 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-16 21:42:22.556  INFO 21908 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 641 ms
2021-09-16 21:42:22.671  INFO 21908 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-09-16 21:42:22.772  INFO 21908 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8081 (http) with context path ''
2021-09-16 21:42:22.778  INFO 21908 --- [           main] com.louris.springboot.Application        : Started Application in 1.109 seconds (JVM running for 1.488)
2021-09-16 21:42:22.793  INFO 21908 --- [           main] o.s.c.a.ConfigurationClassEnhancer       : @Bean method PojoConfig.getPropertySourcesPlaceholderConfigurer is non-static and returns an object assignable to Spring's BeanFactoryPostProcessor interface. This will result in a failure to process annotations such as @Autowired, @Resource and @PostConstruct within the method's declaring @Configuration class. Add the 'static' modifier to this method to avoid these container lifecycle issues; see @Bean javadoc for complete details.
false

使用Spring表达式（Spring EL）

Spring还提供了更灵活的注入方式，那就是Spring表达式。

Spring EL 相关的类

ExpressionParser
TemplateAwareExpressionParser(abstract)
InternalSpelExpressionParser
SpelExpressionParser

表达式创建对象，调用对象方法

//表达式解析器
ExpressionParser parser = new SpelExpressionParser();
//设置表达式
Expression expression = parser.parseExpression("'hello world'");
String str = (String) expression.getValue();
System.out.println(str);

//通过EL访问普通方法
expression = parser.parseExpression("'hello world'.charAt(0)");
char ch = (Character) expression.getValue();
System.out.println(ch);

//通过EL访问的getter方法
expression = parser.parseExpression("'hello world'.bytes");
byte[] bytes = (byte[]) expression.getValue();
System.out.println(bytes);

//通过EL访问属性，相当于“hello world".getBytes().length
expression = parser.parseExpression("'hello world'.bytes.length");
int length = (Integer) expression.getValue();
System.out.println(length);

expression = parser.parseExpression("new String('abc')");
String abc = (String) expression.getValue();
System.out.println(abc);

//创建角色对象
Role role = new Role(1L, "role_name", "note");
expression = parser.parseExpression("note");

//相当于从role中获取备注信息
String note = (String) expression.getValue(role);
System.out.println(note);

//变量环境类，并且将角色对象role作为其根节点
EvaluationContext ctx = new StandardEvaluationContext(role);
//变量环境类操作根节点
parser.parseExpression("note").setValue(ctx, "new_note");
//获取备注，这里的String.class指明，我们希望返回的是一个字符串
note = parser.parseExpression("note").getValue(ctx, String.class);
System.out.println(note);
//调用getRoleName方法
String roleName = parser.parseExpression("getRoleName()").getValue(ctx, String.class);
System.out.println(roleName);

//新增环境变量
List<String> list = new ArrayList<>();
list.add("value1");
list.add("value2");
//给变量环境增加变量
ctx.setVariable("list", list);
//通过表达式去读/写环境变量的值
parser.parseExpression("#list[1]").setValue(ctx, "update_value2");
System.out.println(parser.parseExpression("#list[1]").getValue(ctx));

hello world
h
B@2da3b078
11
abc
note
new_note
role_name
update_value2

Bean的属性和方法

@Value

直接字符串表示赋值
#{}表示Spring EL

${}表示使用配置文件内的属性

package com.louris.springboot.IoCImpl.beans.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component(value = "role")
//@Scope(value = "prototype")
public class Role {
    @Value("#{1}")
    private Long id;
    @Value("#{'role_name_1'}")
    private String roleName;
    @Value("#{'role_note_1'}")
    private String note;
    public Role(){}
    public Role(Long id, String roleName, String note){
        this.id = id;
        this.roleName = roleName;
        this.note = note;
    }

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

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public void setNote(String note) {
        this.note = note;
    }

    public String getRoleName() {
        return roleName;
    }

    public String getNote() {
        return note;
    }

    public Long getId() {
        return id;
    }
}

@Component
public class ElBean{

  //同过beanName获取bean，然后注入
  @Value("#{role}")
  private Role role;

  //获取bean的属性id
  @Value("#{role.id}")
  private Long id;

  //调用bean的getNote方法，获取角色名称
  @Value("#{role.getNote()?.toString()}") //?表示当getNote()不为空，则调用toString()方法
  private String note;
}

使用类的静态常量和方法

@Value("#{T(Math).PI}")
private double pi;

@Value("#{T(java.lang.Math).PT}")
private double pi;

@Value("#{T(Math).random()}")
private double random;

Spring EL运算

@Value("#{role.id + 1}")
private int num;

@Value("#{role.roleName + role.note}")
pring String str;

@Value("#{role.id == 1}")
private boolean equalNum;

@Value("#{role.id > 1 ? 5 : 1}")
private int max;

@Value("#{role.note ? : 'hello'}")
private String defaultString;

面向切面编程

一个简单的约定游戏

约定规则

package com.louris.springboot.aop.interceptors;

public interface Interceptor {
    void before(Object object);

    void after(Object object);

    void afterReturning(Object object);

    void afterThrowing(Object object);
}

package com.louris.springboot;

import com.louris.springboot.aop.interceptors.Interceptor;

public class ProxyBeanFactory {
    public static <T> T getBean(T object, Interceptor interceptor){
        return (T) ProxyBeanUtil.getBean(object, interceptor);
    }
}

package com.louris.springboot;

import com.louris.springboot.aop.interceptors.Interceptor;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyBeanUtil implements InvocationHandler {

    //被代理对象
    private Object object;

    //拦截器
    private Interceptor interceptor = null;

    /**
     * 获取动态代理对象
     * @param object 被代理对象
     * @param interceptor 拦截器
     * @return
     */
    public static Object getBean(Object object, Interceptor interceptor){
        //使用当前类，作为代理方法，此时被代理对象执行方法的时候，会进入当前类的invoke方法里
        ProxyBeanUtil _this = new ProxyBeanUtil();
        //保存被代理对象
        _this.object = object;
        //保存拦截器
        _this.interceptor = interceptor;
        //生成代理对象，并绑定代理方法
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),
                object.getClass().getInterfaces(), _this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object retObj = null;
        //是否产生异常
        boolean exceptionFlag = false;
        //before方法
        interceptor.before(object);
        try{
            //反射原有方法
            retObj = method.invoke(object, args);
        }catch (Exception e){
            exceptionFlag = true;
        }finally {
            //after方法
            interceptor.after(object);
        }
        if(exceptionFlag){
            //afterThrowing方法
            interceptor.afterThrowing(object);
        }else{
            //afterReturning方法
            interceptor.afterReturning(object);
        }
        return retObj;
    }
}

RoleService1 roleService1 = new RoleServiceImpl1();
Interceptor interceptor = new RoleInterceptor();
RoleService1 proxy = ProxyBeanFactory.getBean(roleService1, interceptor);
Role role = new Role(1L, "role_name_1", "role_note_1");
proxy.printRole(role);
System.out.println("########## 测试 afterthrowing 方法 ##########");
role = null;
proxy.printRole(role);

准备打印角色信息
{id =1, roleName=role_name_1,note=role_note_1}
已经完成角色信息的打印处理
刚刚完成打印功能，一切正常。
########## 测试 afterthrowing 方法 ##########
准备打印角色信息
已经完成角色信息的打印处理
打印功能执行异常了，查看一下角色对象为空了吗？

Spring AOP的基本概念

AOP的概念和使用原因

现实中有一些内容并不是面向对象（OOP）可以解决的，比如数据库事务，又如电商网站购物需要经过交易系统、财务系统，对于交易系统存在一个交易记录的对象，而财务系统则存在账户的信息对象。从这个角度而言，我们需要对交易记录和账户操作形成一个统一的事务管理。交易和账户的事务，要么全部成功，要么全部失败。

JDBC数据库事务

这里购买交易的产品和购买记录都在try…catch…finally…语句中，首先需要自己去获取对应的映射器，而业务流程中穿插着事务的提交和回滚，也就是如果交易可以成功，那么就会提交事务，交易如果发生异常，那么就回滚事务，最后在finally语句中会关闭SqlSession所持有的功能。

但这不是一个很好的设计。

public void savePurchaseRecord(Long productId, PurchaseRecord record){
    SqlSession sqlSession = null;
    try{
        sqlSession = SqlSessionFactoryUtils.openSqlSession();
        ProductMapper productMapper = sqlSession.getMapper(ProductMapper.class);
        Product product = productMapper.getRole(productId);
        //判断库存是否大于购买数量
        if(product.getStock() >= record.getQuantity()){
            //减库存，并更新数据库记录
            product.setStock(product.getStock() - record.getQuantity());
            productMapper.update(product);
            //保存交易记录
            PurchaseRecordMapper purchaseRecordMapper = sqlSession.getMapper(PurchaseRecordMapper.class);
            purchaseRecordMapper.save(record);
            sqlSession.commit();
        }
    }catch (Exception e){
        //异常回滚事务
        e.printStackTrace();
        sqlSession.rollback();
    }finally {
        //关闭资源
        if(sqlSession != null) sqlSession.close();
    }
}

Spring AOP对应数据库事务

该代码除了一个注解@Transactional，没有任何关于打开或者关闭数据库资源的代码，更没有任何提交或者回滚数据库事务的代码，但是它却能完成上一节的全部功能。

注意，这段代码更简介，也更容易维护，主要都集中在业务处理上，而不是数据库事务和资源管控上，这就是AOP的魅力；

@Autowired
private ProductMapper productMapper = null;

@Autowired
private PurchaseRecordMapper purchaseRecordMapper = null;

@Transactional
public void updateRoleNote(Long productId, PurchaseRecord record){
    Product product = productMapper.getRole(productId);
    //判断库存是否大于购买数量
    if(product.getStock() >= record.getQuantity()){
        //减库存，并更新数据库记录
        product.setStock(product.getStock() - record.getQuantity());
        productMapper.update(product);
        //保存交易记录
        purchaseRecordMapper.save(record);
    }
}

一个正常的SQL步骤：

打开通过数据库连接池获取数据库连接资源，并做一定的设置工作；
执行对应的SQL语句，对数据进行操作；
如果SQL执行过程中发生异常，回滚事务；
如果SQL执行过程中没有发生异常，最后提交事务；
到最后的阶段，需要关闭一些连接资源。

该过程与之前约定游戏的流程十分接近，也就说作为AOP，完全可以根据这个流程做一定的封装，然后通过动态代理技术，将代码组织入对应的流程环节。

流程如下：

打开获取数据库连接在before方法中完成；
执行SQL，按照读者的逻辑会采用反射的机制调用；
如果发生异常，则回滚事务；如果没有发生异常，则提交事务，然后关闭数据库连接资源；

如果一个AOP框架不需要我们去实现流程中的方法，而是在流程中提供一些通用的方法，并可以通过一定的配置满足各种功能，比如AOP框架帮助你完成了获取数据库，你就不需要知道如何获取数据库连接功能了，此外再增加一些关于事务的重要约定：

在方法标注为@Transactional时，则方法启用数据库事务功能；
在默认的情况下，如果原有方法出现异常，则回滚事务；如果没有发生异常，那么就提交事务，这样真个事务管理AOP就完成了整个流程，无须开发者编写任何代码去实现；
最后关闭数据库资源，这点也比较通用，这里AOP框架也帮你完成它。

这是使用最广的执行流程，符合约定优于配置的开发原则。这些约定的方法加入默认实现后，开发者需要做的只是执行SQL这步而已。大部分情况下，只需要使用默认的约定即可，或者进行一些特定的配置，来完成所需的功能，这样开发者就可以更为关注业务开发，而不是资源控制、事务异常处理，这些AOP框架都可以完成。

面向切面编程的术语

1、切面（Aspect）
切面就是在一个怎样的环境中工作，比如上一节，数据库的事务直接贯穿整个代码层面，这就是一个切面，它能够在被代理对象的方法之前、之后，产生异常或者正常返回后切入你的代码，甚至代替原来被代理对象的方法。

2、通知（Adice）
通知是切面开启后，切面的方法。它根据在代理对象真实方法调用前、后的顺序和逻辑区分，它和约定游戏的例子里的拦截器的方法十分接近。

前置通知（before）：在动态代理反射原有对象方法或者执行环绕通知前执行的通知功能；
后置通知（after）：在动态代理反射原有对象方法或者执行环绕通知后执行的通知后执行的通知功能。无论是否抛出异常，它都会被执行；
返回通知（afterReturning）：在动态代理反射原有对象方法或者执行环绕通知后执行的通知功能；
异常通知（afterThrowing）：在动态代理反射原有对象方法或者执行环绕通知产生异常后执行的通知功能；
环绕通知（aroundThrowing）：在动态代理中，它可以取代当前被拦截对象的方法，通知参数或反射调用被拦截对象的方法。

3、引入（Introduction）
引入允许我们在现有的类里添加自定义的类和方法。

4、切点（Pointcut）
在动态代理中，被切面拦截的方法就是一个切点，切面将可以将其切点和被拦截的方法按照一定的逻辑织入到约定流程当中。

5、连接点（join point）
连接点是一个判断条件，由它可以指定哪些是切点。对于指定的切点，Spring会生成代理对象去使用对应的切面对其拦截，否则就不会拦截它。

6、织入（Weaving）
织入是一个生成代理对象的过程。实际代理的方法分为静态代理和动态代理。静态代理是在编译class文件时生成的代码逻辑，但是在Spring中并不适用这样的方式。

Spring对AOP的支持

AOP并不是Spring框架特有的，Spring只是支持AOP编程的框架之一。每一个框架对AOP的支持各有特点，有些AOP能够对方法的参数进行拦截，有些AOP对方法进行拦截。

而Spring AOP是一种基于方法拦截的AOP，换句话说Spring只能支持方法拦截的AOP，Spring中有4种方式去实现AOP的拦截功能：

使用ProxyFactoryBean和对应的接口实现AOP；
使用XML配置AOP；
使用@AspectJ注解驱动切面；
使用AspectJ注入切面

使用@AspectJ注解开发Spring AOP

注解使用了对应的正则式，这些正则式是连接点的问题，也就是要告诉Spring AOP，需要拦截什么对象的什么方法，为此我们要学习连接点的知识。

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

选择切点

package com.louris.springboot.IoCImpl.service;

import com.louris.springboot.IoCImpl.beans.pojo.Role;

public interface RoleService1 {
    void printRole(Role role);
}

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.service.RoleService1;
import org.springframework.stereotype.Component;

@Component
public class RoleServiceImpl1 implements RoleService1 {

    @Override
    public void printRole(Role role) {
        System.out.println("{id ="+role.getId() + ", roleName=" + role.getRoleName() + "," +
                "note="+role.getNote() + "}");
    }
}

创建切面

package com.louris.springboot.aspects;

import org.aspectj.lang.annotation.*;

@Aspect
public class RoleAspect {

    @Before(value = "execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl1.printRole(..))")
    public void before(){
        System.out.println("before ....");
    }

    @After(value = "execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl1.printRole(..))")
    public void after(){
        System.out.println("after ....");
    }

    @AfterReturning(value = "execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl1.printRole(..))")
    public void afterReturning(){
        System.out.println("afterReturning ....");
    }

    @AfterThrowing(value = "execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl1.printRole(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing ....");
    }
}

注解	通知	备注
@Before	在被代理对象的方法前先调用	前置通知
@Around	将被代理对象的方法封装起来，并用环绕通知取代它	环绕通知，它将覆盖原有方法，但是允许你通过反射调用原有方法，后续会讨论
@After	在被代理对象的方法后调用	后置通知
@AfterReturning	在被代理对象的方法正常返回后调用	返回通知，要求被代理对象的方法执行过程中没有发生异常
@AfterThrowing	在被代理对象的方法抛出异常后调用	异常通知，要求被代理对象的方法执行过程中产生异常

连接点

1	execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl1.printRole(..))

execution：代表执行方法的时候触发
*：代表任意返回类型的方法
com.louris.springboot.IoCImpl.impl.RoleServiceImpl1：代表类的全限定名
printRole：被拦截方法名称
(..)：任意的参数

AspectJ指示器	描述
arg()	限制连接点匹配参数为指定类型的方法
@args()	限制连接点匹配参数为指定注解标注的执行方法
execution	用于匹配连接点的执行方法，这是最常用的匹配，可以通过类似上面的正则式进行匹配
this()	限制连接点匹配AOP代理的Bean，引用为指定类型的类
target	限制连接点匹配被代理对象为指定的类型
@target()	限制连接点匹配特定的执行对象，这些对象要符合指定的注解类型
within()	限制连接点匹配指定的包
@within()	限制连接点匹配指定的类型
@annotation	限制匹配带有指定注解的连接点

通过within限制，Spring只会拿到com.louris.springboot.IoCImpl.impl包下面的类的printRole方法作为切点了。

@Before(value = "execution(* com.louris.springboot.*.*.*.printRole(..))
                 && within(com.louris.springboot.IoCImpl.impl)")
public void before(){
    System.out.println("before ....");
}

package com.louris.springboot.aspects;

import org.aspectj.lang.annotation.*;

@Aspect
public class RoleAspect {

    @Pointcut(value = "execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl1.printRole(..))")
    public void print(){}

    @Before(value = "print()")
    public void before(){
        System.out.println("before ....");
    }

    @After(value = "print()")
    public void after(){
        System.out.println("after ....");
    }

    @AfterReturning(value = "print()")
    public void afterReturning(){
        System.out.println("afterReturning ....");
    }

    @AfterThrowing(value = "print()")
    public void afterThrowing(){
        System.out.println("afterThrowing ....");
    }
}

测试AOP

注解实现

package com.louris.springboot.IoCImpl.config;

import com.louris.springboot.aspects.RoleAspect;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
@ComponentScan(value = "com.louris.springboot.*")
public class AopConfig {
    @Bean
    public RoleAspect getRoleAspect(){
        return new RoleAspect();
    }
}

XML实现

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <!--<context:component-scan base-package="com.louris.springboot.IoCImpl.beans"/>-->
    <aop:aspectj-autoproxy/>
    <bean id="roleAspect" class="com.louris.springboot.aspects.RoleAspect"/>
    <bean id="roleService" class="com.louris.springboot.IoCImpl.impl.RoleServiceImpl1"/>
</beans>

测试

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AopConfig.class);
//ApplicationContext applicationContext1 = new ClassPathXmlApplicationContext("sprint-aop-config.xml");
RoleService1 roleService1 = (RoleService1) applicationContext.getBean(RoleService1.class);
Role role = new Role();
role.setId(1L);
role.setRoleName("role_name_1");
role.setNote("note_1");
roleService1.printRole(role);
System.out.println("#################");
//测试异常通知
role = null;
roleService1.printRole(role);

运行结果

before ....
{id =1, roleName=role_name_1,note=note_1}
afterReturning ....
after ....
#################
before ....
afterThrowing ....
after ....
Exception in thread "main" java.lang.NullPointerException
	at com.louris.springboot.IoCImpl.impl.RoleServiceImpl1.printRole(RoleServiceImpl1.java:12)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.base/java.lang.reflect.Method.invoke(Method.java:564)
	at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:344)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:198)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)
	at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:64)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:57)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.aspectj.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:49)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:58)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:97)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:215)
	at com.sun.proxy.$Proxy67.printRole(Unknown Source)
	at com.louris.springboot.Application.main(Application.java:100)

环绕通知

环绕通知是Spring AOP中最强大的通知，它可以同时实现前置通知和后置通知。它保留了调度被代理对象原有方法的功能，所以它既强大，又灵活。但是由于强大，它的可控性不那么强，如果不需要大量改变业务逻辑，一般而言并不需要使用它。

@Around(value = "print()")
public void around(ProceedingJoinPoint joinPoint){
    System.out.println("around before ....");
    try{
        joinPoint.proceed();
    }catch (Throwable e){
        e.printStackTrace();
    }
    System.out.println("around after ....");
}

around before ....
before ....
{id =1, roleName=role_name_1,note=note_1}
afterReturning ....
after ....
around after ....
#################
around before ....
before ....
afterThrowing ....
after ....
around after ....
java.lang.NullPointerException

织入

织入是生成代理对象的过程，在上述的代码中，切点方法所在的类都是拥有接口的类，而事实上即使没有接口，Spring也能提供AOP的功能，所以是否拥有接口不是使用Spring AOP的一个强制要求。

当类的实现存在接口时，Spring将提供JDK动态代理，从而织入各个通知；
当类不存在接口的时候没有办法使用JDK动态代理，Spring会采用CGLIB来生成代理对象。

给通知传递参数

1
2
3

public interface RoleService1 {
    void printRole(Role role, int sort);
}

@Component
public class RoleServiceImpl1 implements RoleService1 {

    @Override
    public void printRole(Role role, int sort) {
        System.out.println("{id ="+role.getId() + ", roleName=" + role.getRoleName() + "," +
                "note="+role.getNote() + "}");
        System.out.println(sort);
    }
}

@Before(value = "execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl1.printRole(..))" +
        "&& args(role, sort)")
public void before(Role role, int sort){
    System.out.println("before ....");
    System.out.println(role.getRoleName());
    System.out.println(sort);
    System.out.println("before exit....");
}

运行结果

around before ....
before ....
role_name_1
1
before exit....
{id =1, roleName=role_name_1,note=note_1}
1
afterReturning ....
after ....
around after ....
#################
around before ....
before ....
around after ....
java.lang.NullPointerException

引入

Spring AOP只是通过动态代理技术，把各类通知织入到它所约定的流程当中，而事实上，有时候我们希望通过引入其他类的方法来得到更好的实现，这时就可以引入其他的方法了。

package com.louris.springboot.IoCImpl.service;

import com.louris.springboot.IoCImpl.beans.pojo.Role;

public interface RoleVerifier {
    boolean verify(Role role);
}

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.service.RoleVerifier;
import org.springframework.stereotype.Component;

public class RoleVerifierImpl implements RoleVerifier {
    @Override
    public boolean verify(Role role) {
        return role != null;
    }
}

注解@DeclareParents的配置：

value 表示对对应类进行增强，也就是在对应类中引入一个新的接口
defaultImpl 代表其默认的实现类，这里是RoleVerifierImpl

package com.louris.springboot.aspects;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.impl.RoleServiceImpl;
import com.louris.springboot.IoCImpl.impl.RoleVerifierImpl;
import com.louris.springboot.IoCImpl.service.RoleVerifier;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class RoleAspect {

    @DeclareParents(value = "com.louris.springboot.IoCImpl.impl.RoleServiceImpl",
    defaultImpl = RoleVerifierImpl.class)
    public RoleVerifier roleVerifier;

    @Pointcut(value = "execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl.printRole(..))")
    public void print(){}

    @Around(value = "print()")
    public void around(ProceedingJoinPoint joinPoint){
        System.out.println("around before ....");
        try{
            joinPoint.proceed();
        }catch (Throwable e){
            e.printStackTrace();
        }
        System.out.println("around after ....");
    }

    @Before(value = "print()")
    public void before(){
        System.out.println("before ....");
    }

    @After(value = "print()")
    public void after(){
        System.out.println("after ....");
    }

    @AfterReturning(value = "print()")
    public void afterReturning(){
        System.out.println("afterReturning ....");
    }

    @AfterThrowing(value = "print()")
    public void afterThrowing(){
        System.out.println("afterThrowing ....");
    }
}

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AopConfig.class);
RoleService roleService = applicationContext.getBean(RoleService.class);
RoleVerifier roleVerifier = (RoleVerifier) roleService;
Role role = new Role();
role.setId(1L);
role.setRoleName("role_name_1");
role.setNote("note_1");
if(roleVerifier.verify(role)){
    System.out.println("role is not null!");
    roleService.printRole(role);
}

role is not null!
around before ....
before ....
{id =1, roleName=role_name_1,note=note_1}
afterReturning ....
after ....
around after ....

可以看到通过Spirng AOP后，使用强制转换后就可以把roleService转化为roleVerifier接口对象，然后就可以使用verify方法。而RoleVerifer调用的方法verify，显然它就是通过RoleVerifierImpl来实现的。

其原理是通过Spring AOP依赖于动态代理来实现，生成动态代理对象是通过类似于下面这行代码来实现的。

1	return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), _this);

obj.getClass().getInterfaces()意味着代理对象挂在多个接口之下，换句话说，只要Spring AOP让代理对象挂到RoleService和RoleVerifier两个接口之下，那么就可以把对应的Bean通过强制转换，让其在RoleService和RoleVerifier之间相互转换了。

同样的如果RoleServiceImpl没有接口，那么它会使用CGLIB动态代理，使用增强着（Enhancer）也会有一个Interfaces的属性，允许代理对象挂到对应的多个接口下，于是也可以按JDK动态代理那样使得对象可以在多个接口之间相互转换。

使用XML配置开发Spring AOP

切点不变，即RoleService和RoleServiceImpl不变

package com.louris.springboot.aspects;


import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.service.RoleVerifier;
import org.aspectj.lang.ProceedingJoinPoint;

public class XmlAspect {

    public RoleVerifier roleVerifier = null;

    public void before(Role role){
        System.out.println("role_id= " + role.getId() + " before ....");
    }

    public void after(){
        System.out.println("after ....");
    }

    public void afterReturning(){
        System.out.println("afterReturning ....");
    }

    public void afterThrowing(){
        System.out.println("afterThrowing ....");
    }

    public void around(ProceedingJoinPoint joinPoint){
        System.out.println("around before ....");
        try{
            joinPoint.proceed();
        }catch (Throwable e){
            e.printStackTrace();
        }
        System.out.println("around after ....");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="xmlAspect" class="com.louris.springboot.aspects.XmlAspect"/>
    <bean id="roleService" class="com.louris.springboot.IoCImpl.impl.RoleServiceImpl"/>
    <!--<aop:config>-->
    <!--    &lt;!&ndash; 引用xmlAspect作为切面 &ndash;&gt;-->
    <!--    <aop:aspect ref="xmlAspect">-->
    <!--        &lt;!&ndash; 定义通知 &ndash;&gt;-->
    <!--        <aop:before method="before" pointcut="execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl.printRole(..))"/>-->
    <!--        <aop:after method="after" pointcut="execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl.printRole(..))"/>-->
    <!--        <aop:after-throwing method="afterThrowing" pointcut="execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl.printRole(..))"/>-->
    <!--        <aop:after-returning method="afterReturning" pointcut="execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl.printRole(..))"/>-->
    <!--    </aop:aspect>-->
    <!--</aop:config>-->
    <aop:config>
        <!-- 引用xmlAspect作为切面 -->
        <aop:aspect ref="xmlAspect">
            <!-- 定义切点 -->
            <aop:pointcut id="printRole" expression="execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl.printRole(..))"/>
            <aop:declare-parents types-matching="com.louris.springboot.IoCImpl.impl.RoleServiceImpl"
                                 implement-interface="com.louris.springboot.IoCImpl.service.RoleVerifier"
                                 default-impl="com.louris.springboot.IoCImpl.impl.RoleVerifierImpl"/>
            <!-- 定义通知 -->
            <aop:before method="before" pointcut="execution(* com.louris.springboot.IoCImpl.impl.RoleServiceImpl.printRole(..)) and args(role)"/>
            <aop:after method="after" pointcut-ref="printRole"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="printRole"/>
            <aop:after-returning method="afterReturning" pointcut-ref="printRole"/>
            <aop:around method="around" pointcut-ref="printRole"/>
        </aop:aspect>
    </aop:config>
</beans>

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-aop.xml");
RoleService roleService = applicationContext.getBean(RoleService.class);
RoleVerifier roleVerifier = (RoleVerifier) roleService;
Role role = new Role();
role.setId(1L);
role.setRoleName("role_name_1");
role.setNote("note_1");
if(roleVerifier.verify(role)){
    System.out.println("role is not null!");
    roleService.printRole(role);
}

经典Spring AOP应用程序

略过

多个切面

package com.louris.springboot.IoCImpl.service;

public interface MultiBean {
    void testMulti();
}

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.service.MultiBean;
import org.springframework.stereotype.Component;

@Component
public class MultiBeanImpl implements MultiBean {

    @Override
    public void testMulti() {
        System.out.println("test multi aspects!!");
    }
}

package com.louris.springboot.aspects;

import com.louris.springboot.IoCImpl.impl.RoleVerifierImpl;
import com.louris.springboot.IoCImpl.service.RoleVerifier;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;

@Aspect
//@Order(3)
public class Aspect1 {

    @Pointcut(value = "execution(* com.louris.springboot.IoCImpl.impl.MultiBeanImpl.testMulti(..))")
    public void print(){}

    @Before(value = "print()")
    public void before(){
        System.out.println("before 1 ....");
    }

    @After(value = "print()")
    public void after(){
        System.out.println("after 1 ....");
    }

    @AfterReturning(value = "print()")
    public void afterReturning(){
        System.out.println("afterReturning 1 ....");
    }

    @AfterThrowing(value = "print()")
    public void afterThrowing(){
        System.out.println("afterThrowing 1 ....");
    }
}

package com.louris.springboot.aspects;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;

@Aspect
//@Order(2)
public class Aspect2 {

    @Pointcut(value = "execution(* com.louris.springboot.IoCImpl.impl.MultiBeanImpl.testMulti(..))")
    public void print(){}

    @Before(value = "print()")
    public void before(){
        System.out.println("before 2 ....");
    }

    @After(value = "print()")
    public void after(){
        System.out.println("after 2 ....");
    }

    @AfterReturning(value = "print()")
    public void afterReturning(){
        System.out.println("afterReturning 2 ....");
    }

    @AfterThrowing(value = "print()")
    public void afterThrowing(){
        System.out.println("afterThrowing 2 ....");
    }
}

package com.louris.springboot.aspects;

import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;

@Aspect
//@Order(1)
public class Aspect3 {

    @Pointcut(value = "execution(* com.louris.springboot.IoCImpl.impl.MultiBeanImpl.testMulti(..))")
    public void print(){}

    @Before(value = "print()")
    public void before(){
        System.out.println("before 3 ....");
    }

    @After(value = "print()")
    public void after(){
        System.out.println("after 3 ....");
    }

    @AfterReturning(value = "print()")
    public void afterReturning(){
        System.out.println("afterReturning 3 ....");
    }

    @AfterThrowing(value = "print()")
    public void afterThrowing(){
        System.out.println("afterThrowing 3 ....");
    }
}

package com.louris.springboot.IoCImpl.config;

import com.louris.springboot.aspects.Aspect1;
import com.louris.springboot.aspects.Aspect2;
import com.louris.springboot.aspects.Aspect3;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.context.annotation.*;

@Configuration
@EnableAspectJAutoProxy
@ComponentScan(basePackages = {"com.louris.springboot"})
public class MultiConfig {

    @Bean
    public Aspect1 getAspect1(){
        return new Aspect1();
    }

    @Bean
    public Aspect2 getAspect2(){
        return new Aspect2();
    }

    @Bean
    public Aspect3 getAspect3(){
        return new Aspect3();
    }
}

1
2
3

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MultiConfig.class);
MultiBean multiBean = applicationContext.getBean(MultiBeanImpl.class);
multiBean.testMulti();

多切面排序

运行结果：
（1）默认顺序：应该是切面类名字符排序

before 1 ....
before 2 ....
before 3 ....
test multi aspects!!
afterReturning 3 ....
after 3 ....
afterReturning 2 ....
after 2 ....
afterReturning 1 ....
after 1 ....

（2）@Order注解指定顺序

before 3 ....
before 2 ....
before 1 ....
test multi aspects!!
afterReturning 1 ....
after 1 ....
afterReturning 2 ....
after 2 ....
afterReturning 3 ....
after 3 ....

（3）其他方式：

@Aspect
public lcass Aspect1 implements Ordered{

  @Override
  public int getOrder(){
    return 1;
  }
}

1
2
3

<aop:aspect ref="aspect1" order="1">
  ......
</aop:aspect>

Spring和数据库编程

传统的JDBC代码的弊端

执行一条简单的SQL，其过程也不简单，太多try…catch…finally

public Role getRole(Long id){
    Role role = null;
    //生命JDBC变量
    Connection connection = null;
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    try{
        //注册驱动程序
        Class.forName("com.mysql.cj.jdbc.Driver");
        //获取连接
        connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/ssm",
                "root",
                "123456");
        //预编译SQL
        preparedStatement = connection.prepareStatement("select id, role_name, note from t_role where id = ?");
        //设置参数
        preparedStatement.setLong(1, id);
        //执行SQL
        resultSet = preparedStatement.executeQuery();
        //组装结果集返回POJO
        while(resultSet.next()){
            role = new Role();
            role.setId(resultSet.getLong(1));
            role.setRoleName(resultSet.getString(2));
            role.setNote(resultSet.getString(3));
        }
    }catch (ClassNotFoundException | SQLException e){
        //异常处理
        e.printStackTrace();
    }finally {
        //关闭数据库连接资源
        try{
            if(resultSet != null && !resultSet.isClosed()){
                resultSet.close();
            }
        }catch (SQLException e){
            e.printStackTrace();
        }
        try{
            if(preparedStatement != null && !preparedStatement.isClosed()){
                preparedStatement.close();
            }
        }catch (SQLException e){
            e.printStackTrace();
        }
        try{
            if(connection != null && !connection.isClosed()){
                connection.close();
            }
        }catch (SQLException e){
            e.printStackTrace();
        }
    }
    return role;
}

配置数据库资源

使用简单数据库配置

<bean id="dataSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
      <property name="username" value="root"/>
      <property name="password" value="123456"/>
      <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://localhost:3306/ssm"/>
</bean>

使用第三方数据库连接池

<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
    <!--  连接池的最大数据库连接数  -->
    <property name="maxTotal" value="255"/>
    <!--  最大等待连接中的数量  -->
    <property name="maxIdle" value="5"/>
    <!-- 最大等待毫秒数 -->
    <property name="maxWaitMillis" value="10000"/>
</bean>

使用JNDI数据库连接池

1
2
3

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
      <property name="jndiName" value="java:comp/env/jdbc/ssm"/>
</bean>

JDBC代码失控的解决方案——JdbcTemplate

JdbcTemplate是Spring针对JDBC代码失控提供的解决方案，严格来说，它本身也不算成功。但是无论如何jdbcTemplate的方案也体现了Spring框架的主导思想之一：给予常用技术提供模板化的编程，减少了开发者的工作量。

JdbcTemplate的增删改查

1
2
3

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
      <property name="dataSource" ref="dataSource"/>
</bean>

package com.louris.springboot.utils;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import org.springframework.jdbc.core.JdbcTemplate;

import java.sql.ResultSet;
import java.util.List;

public class JdbcTemplateTest {

    /**
     * 插入角色
     * @param jdbcTemplate 模板
     * @return 影响条数
     */
    public int insertRole(JdbcTemplate jdbcTemplate){
        String roleName = "rolt_name_1";
        String note = "note_1";
        String sql = "insert into t_role(role_name, note) value(?,?)";
        return jdbcTemplate.update(sql, roleName, note);
    }

    /**
     * 删除角色
     * @param jdbcTemplate 模板
     * @param id 角色编号，主键
     * @return 影响条数
     */
    public int deleteRole(JdbcTemplate jdbcTemplate, Long id){
        String sql = "delete from t_role where id=?";
        return jdbcTemplate.update(sql, id);
    }

    public int updateRole(JdbcTemplate jdbcTemplate, Role role){
        String sql = "update t_role set role_name=?, note=? where id=?";
        return jdbcTemplate.update(sql, role.getRoleName(), role.getNote(), role.getId());
    }

    public List<Role> findRole(JdbcTemplate jdbcTemplate, String roleName){
        String sql = "select id, role_name, note from t_role where role_name like concat('%', ?, '%')";
        Object[] params = {roleName}; //组织参数
        //使用RowMapper接口组织返回（使用lambda表达式）
        List<Role> list = jdbcTemplate.query(sql, params, (ResultSet resultSet, int rowNum) -> {
            Role result = new Role();
            result.setId(resultSet.getLong("id"));
            result.setRoleName(resultSet.getString("role_name"));
            result.setNote(resultSet.getString("note"));
            return result;
        });
        return list;
    }
}

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-dataSource.xml");
JdbcTemplate jdbcTemplate = applicationContext.getBean(JdbcTemplate.class);
Long id = 2L;
String sql = "select id, role_name, note from t_role where id = " + id;
Role role = jdbcTemplate.queryForObject(sql, new RowMapper<Role>() {
    @Override
    public Role mapRow(ResultSet resultSet, int i) throws SQLException {
        Role result = new Role();
        result.setId(resultSet.getLong("id"));
        result.setRoleName(resultSet.getString("role_name"));
        result.setNote(resultSet.getString("note"));
        return result;
    }
});
System.out.println(role.getRoleName());

JdbcTemplateTest jdbcTemplateTest = new JdbcTemplateTest();
jdbcTemplateTest.insertRole(jdbcTemplate);

role = new Role();
role.setId(13L);
role.setRoleName("update_role_name_1");
role.setNote("update_note_1");
jdbcTemplateTest.updateRole(jdbcTemplate, role);
jdbcTemplateTest.deleteRole(jdbcTemplate, 11L);

运行结果

"C:\Program Files\Java\jdk-14.0.2\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dspring.jmx.enabled=true -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=65017:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\SpringBootCourse\001-springboot-first\target\classes;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.4.4\spring-boot-starter-web-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter\2.4.4\spring-boot-starter-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.4.4\spring-boot-autoconfigure-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.4.4\spring-boot-starter-logging-2.4.4.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\98383\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.13.3\log4j-to-slf4j-2.13.3.jar;C:\Users\98383\.m2\repository\org\apache\logging\log4j\log4j-api\2.13.3\log4j-api-2.13.3.jar;C:\Users\98383\.m2\repository\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;C:\Users\98383\.m2\repository\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;C:\Users\98383\.m2\repository\org\yaml\snakeyaml\1.27\snakeyaml-1.27.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.4.4\spring-boot-starter-json-2.4.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.11.4\jackson-databind-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.11.4\jackson-annotations-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.11.4\jackson-core-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.11.4\jackson-datatype-jdk8-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.11.4\jackson-datatype-jsr310-2.11.4.jar;C:\Users\98383\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.11.4\jackson-module-parameter-names-2.11.4.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.4.4\spring-boot-starter-tomcat-2.4.4.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\9.0.44\tomcat-embed-core-9.0.44.jar;C:\Users\98383\.m2\repository\org\glassfish\jakarta.el\3.0.3\jakarta.el-3.0.3.jar;C:\Users\98383\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.44\tomcat-embed-websocket-9.0.44.jar;C:\Users\98383\.m2\repository\org\springframework\spring-web\5.3.5\spring-web-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-webmvc\5.3.5\spring-webmvc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-expression\5.3.5\spring-expression-5.3.5.jar;C:\Users\98383\.m2\repository\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\98383\.m2\repository\org\springframework\spring-core\5.3.5\spring-core-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jcl\5.3.5\spring-jcl-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-beans\5.3.5\spring-beans-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot\2.4.4\spring-boot-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-context\5.3.5\spring-context-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-aop\2.4.4\spring-boot-starter-aop-2.4.4.jar;C:\Users\98383\.m2\repository\org\springframework\spring-aop\5.3.5\spring-aop-5.3.5.jar;C:\Users\98383\.m2\repository\org\aspectj\aspectjweaver\1.9.6\aspectjweaver-1.9.6.jar;C:\Users\98383\.m2\repository\org\apache\commons\commons-dbcp2\2.8.0\commons-dbcp2-2.8.0.jar;C:\Users\98383\.m2\repository\org\apache\commons\commons-pool2\2.9.0\commons-pool2-2.9.0.jar;C:\Users\98383\.m2\repository\mysql\mysql-connector-java\8.0.23\mysql-connector-java-8.0.23.jar;C:\Users\98383\.m2\repository\org\mybatis\spring\boot\mybatis-spring-boot-starter\2.0.0\mybatis-spring-boot-starter-2.0.0.jar;C:\Users\98383\.m2\repository\org\springframework\boot\spring-boot-starter-jdbc\2.4.4\spring-boot-starter-jdbc-2.4.4.jar;C:\Users\98383\.m2\repository\com\zaxxer\HikariCP\3.4.5\HikariCP-3.4.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-jdbc\5.3.5\spring-jdbc-5.3.5.jar;C:\Users\98383\.m2\repository\org\springframework\spring-tx\5.3.5\spring-tx-5.3.5.jar;C:\Users\98383\.m2\repository\org\mybatis\spring\boot\mybatis-spring-boot-autoconfigure\2.0.0\mybatis-spring-boot-autoconfigure-2.0.0.jar;C:\Users\98383\.m2\repository\org\mybatis\mybatis\3.5.0\mybatis-3.5.0.jar;C:\Users\98383\.m2\repository\org\mybatis\mybatis-spring\2.0.0\mybatis-spring-2.0.0.jar com.louris.springboot.Application
Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  `  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.4)

2021-09-20 10:33:08.441  INFO 22956 --- [           main] com.louris.springboot.Application        : Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 22956 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-20 10:33:08.443  INFO 22956 --- [           main] com.louris.springboot.Application        : No active profile set, falling back to default profiles: default
2021-09-20 10:33:08.901  WARN 22956 --- [           main] o.m.s.mapper.ClassPathMapperScanner      : No MyBatis mapper was found in '[com.louris.springboot]' package. Please check your configuration.
2021-09-20 10:33:09.001  INFO 22956 --- [           main] o.s.c.a.ConfigurationClassEnhancer       : @Bean method PojoConfig.getPropertySourcesPlaceholderConfigurer is non-static and returns an object assignable to Spring's BeanFactoryPostProcessor interface. This will result in a failure to process annotations such as @Autowired, @Resource and @PostConstruct within the method's declaring @Configuration class. Add the 'static' modifier to this method to avoid these container lifecycle issues; see @Bean javadoc for complete details.
2021-09-20 10:33:09.291  INFO 22956 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8081 (http)
2021-09-20 10:33:09.297  INFO 22956 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-20 10:33:09.297  INFO 22956 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-20 10:33:09.367  INFO 22956 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-20 10:33:09.367  INFO 22956 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 878 ms
2021-09-20 10:33:09.530  INFO 22956 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-09-20 10:33:09.705  INFO 22956 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8081 (http) with context path ''
2021-09-20 10:33:09.712  INFO 22956 --- [           main] com.louris.springboot.Application        : Started Application in 1.502 seconds (JVM running for 1.887)
John

执行多条SQL

一个JdbcTemplate只执行了一条SQL，当要多次执行SQL时，可以使用execute方法。它将允许传递ConnectionCallback或者StatementCallback等接口进行回调，从而完成对应的功能。

public Role getRoleByConnectionCallback(JdbcTemplate jdbcTemplate, Long id){
    Role role = null;
    //这里写成Java 8的Lambda表达式，如果你使用低版本的Java，需要使用ConnectionCallback匿名类
    role = jdbcTemplate.execute((Connection connection) -> {
        Role result = null;
        String sql = "select id, role_name, note from t_role where id = ?";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setLong(1, id);
        ResultSet resultSet = preparedStatement.executeQuery();
        while(resultSet.next()){
            result = new Role();
            result.setId(resultSet.getLong("id"));
            result.setNote(resultSet.getString("note"));
            result.setRoleName(resultSet.getString("role_name"));
        }
        return result;
    });

    return role;
}

public Role getRoleByStatementCallback(JdbcTemplate jdbcTemplate, Long id){
    Role role = null;
    role = jdbcTemplate.execute((Statement statement) -> {
        Role result = null;
        String sql = "select id, role_name, note from t_role where id=" + id;
        ResultSet resultSet = statement.executeQuery(sql);
        while(resultSet.next()){
            result = new Role();
            result.setId(resultSet.getLong("id"));
            result.setNote(resultSet.getString("note"));
            result.setRoleName(resultSet.getString("role_name"));
        }
        return result;
    });
    return role;
}

JdbcTemplate源码分析

从源码中可以看到， Spring 要实现数据库连接资源获取和释放的逻辑，只要完成回调接口的方法逻辑即可，这便是它所提供的模板功能。但是我们并没有看到任何的事务管理，因为 jdbcTemplate 是不能支持事务的，还需要引入对应的事务管理器才能够支持事务。
在Spring 中，它会在内部再次判断事务是否交由事务管理器处理，如果是，则数据库连接将会从数据库事务管理器中获取，并且 jdbcTemplate 的资源链接请求的关闭也将由务管理器决定，而不是由 jdbcTemplate 自身决定。由于这里只是简单应用，数据库事务并没有交由事务管理器管理，所以数据库资源是由 jdbcTemplate 自身管理。

@Nullable
private <T> T execute(StatementCallback<T> action, boolean closeResources) throws DataAccessException {
    Assert.notNull(action, "Callback object must not be null");
    Connection con = DataSourceUtils.getConnection(this.obtainDataSource());
    Statement stmt = null;

    Object var12;
    try {
        stmt = con.createStatement();
        this.applyStatementSettings(stmt);
        T result = action.doInStatement(stmt);
        this.handleWarnings(stmt);
        var12 = result;
    } catch (SQLException var10) {
        String sql = getSql(action);
        JdbcUtils.closeStatement(stmt);
        stmt = null;
        DataSourceUtils.releaseConnection(con, this.getDataSource());
        con = null;
        throw this.translateException("StatementCallback", sql, var10);
    } finally {
        if (closeResources) {
            JdbcUtils.closeStatement(stmt);
            DataSourceUtils.releaseConnection(con, this.getDataSource());
        }

    }

    return var12;
}

MyBatis-Spring项目

配置SqlSessionFactoryBean


public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
    private static final Logger LOGGER = LoggerFactory.getLogger(SqlSessionFactoryBean.class); //日志
    private Resource configLocation; //MyBatis配置文件
    private Configuration configuration; //Configuration对象
    private Resource[] mapperLocations; //Mapper配置路径
    private DataSource dataSource; //数据库
    private TransactionFactory transactionFactory; //事务管理器
    private Properties configurationProperties; //配置属性
    private SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    private SqlSessionFactory sqlSessionFactory;
    private String environment = SqlSessionFactoryBean.class.getSimpleName();
    private boolean failFast; //当加载后，是否检测所有MyBatis的映射语句加载完全，默认为false
    private Interceptor[] plugins; //插件
    private TypeHandler<?>[] typeHandlers; //类型转换器，typeHandlers
    private String typeHandlersPackage; //类型转换器包，用于扫描装载
    private Class<?>[] typeAliases; //别名
    private String typeAliasesPackage; //别名包，用于扫描加载
    private Class<?> typeAliasesSuperType; //当扩展了上面Class类后，就生成别名，但是如果你没有配置typeAliasesPackage则不会生效
    private DatabaseIdProvider databaseIdProvider; //数据库厂商标识
    private Class<? extends VFS> vfs; //unix的文件操作
    private Cache cache; //缓存
    private ObjectFactory objectFactory; ///对象工厂
    private ObjectWrapperFactory objectWrapperFactory; //对象包装器
}

其他略过，springboot只需要配置properties文件就可以了

深入Spring数据库事务管理

Spring数据库事务管理器的设计

在Spring中数据库事务是通过PlatformTransactionManager进行管理的，而能够支持事务的是org.springframework.transaction.support.TransactionTemplate模板，它是Spring所提供的事务管理器的模板。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.transaction;

import org.springframework.lang.Nullable;

public interface PlatformTransactionManager extends TransactionManager {
    //获取事务状态
    TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;
    //提交事务
    void commit(TransactionStatus var1) throws TransactionException;
    //回滚事务
    void rollback(TransactionStatus var1) throws TransactionException;
}

从源码可以看到：

事务的创建、提交和回滚是通过PlatformTransactionManager接口来完成的；
当事务产生异常时会回滚事务，在默认的实现中所有的异常都会回滚。我们可以通过配置去修改在某些异常发生时回滚或者不回滚事务；
当无异常时，会提交事务。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.transaction.support;

import java.lang.reflect.UndeclaredThrowableException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.lang.Nullable;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.TransactionSystemException;
import org.springframework.util.Assert;

public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean {
    protected final Log logger = LogFactory.getLog(this.getClass());
    @Nullable
    private PlatformTransactionManager transactionManager; //事务管理器

    public TransactionTemplate() {
    }

    public TransactionTemplate(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    public TransactionTemplate(PlatformTransactionManager transactionManager, TransactionDefinition transactionDefinition) {
        super(transactionDefinition);
        this.transactionManager = transactionManager;
    }

    public void setTransactionManager(@Nullable PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    @Nullable
    public PlatformTransactionManager getTransactionManager() {
        return this.transactionManager;
    }

    public void afterPropertiesSet() {
        if (this.transactionManager == null) {
            throw new IllegalArgumentException("Property 'transactionManager' is required");
        }
    }

    @Nullable
    public <T> T execute(TransactionCallback<T> action) throws TransactionException {
        Assert.state(this.transactionManager != null, "No PlatformTransactionManager set");
        //使用自定义的事务管理器
        if (this.transactionManager instanceof CallbackPreferringPlatformTransactionManager) {
            return ((CallbackPreferringPlatformTransactionManager)this.transactionManager).execute(this, action);
        } else { //系统默认管理器
          //获取事务状态
            TransactionStatus status = this.transactionManager.getTransaction(this);

            Object result;
            try {
                result = action.doInTransaction(status); //回调接口方法
            } catch (Error | RuntimeException var5) {
                //Transactional code threw applicatiion exception -> rollback
                //回滚异常方法
                this.rollbackOnException(status, var5);
                throw var5; //抛出异常
            } catch (Throwable var6) {
                //Transactional code threw error -> rollback
                //回滚异常方法
                this.rollbackOnException(status, var6);
                throw new UndeclaredThrowableException(var6, "TransactionCallback threw undeclared checked exception"); //抛出异常
            }

            this.transactionManager.commit(status); //提交事务
            return result; //返回结果
        }
    }

    private void rollbackOnException(TransactionStatus status, Throwable ex) throws TransactionException {
        Assert.state(this.transactionManager != null, "No PlatformTransactionManager set");
        this.logger.debug("Initiating transaction rollback on application exception", ex);

        try {
            this.transactionManager.rollback(status);
        } catch (TransactionSystemException var4) {
            this.logger.error("Application exception overridden by rollback exception", ex);
            var4.initApplicationException(ex);
            throw var4;
        } catch (Error | RuntimeException var5) {
            this.logger.error("Application exception overridden by rollback exception", ex);
            throw var5;
        }
    }

    public boolean equals(@Nullable Object other) {
        return this == other || super.equals(other) && (!(other instanceof TransactionTemplate) || this.getTransactionManager() == ((TransactionTemplate)other).getTransactionManager());
    }
}

配置事务管理器

<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
    <!--  连接池的最大数据库连接数  -->
    <property name="maxTotal" value="255"/>
    <!--  最大等待连接中的数量  -->
    <property name="maxIdle" value="5"/>
    <!-- 最大等待毫秒数 -->
    <property name="maxWaitMillis" value="10000"/>
</bean>

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

编程式事务

package com.louris.springboot.IoCImpl.config;

import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.lang.NonNull;
import org.springframework.lang.NonNullApi;
import org.springframework.transaction.TransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.TransactionManagementConfigurer;

import javax.sql.DataSource;
import javax.xml.crypto.Data;
import java.util.Properties;

@Configuration
@ComponentScan(basePackages = {"com.louris.springboot"})
@EnableTransactionManagement
public class TransactionConfig implements TransactionManagementConfigurer {

    private DataSource dataSource = null;

    @Bean(name = "dataSource")
    public DataSource initDataSource(){
        if(dataSource != null){
            return dataSource;
        }

        Properties properties = new Properties();
        properties.setProperty("driverClassName", "com.mysql.cj.jdbc.Driver");
        properties.setProperty("url", "jdbc:mysql://localhost:3306/ssm");
        properties.setProperty("username", "root");
        properties.setProperty("password", "123456");
        properties.setProperty("maxTotal", "200");
        properties.setProperty("maxIdle", "20");
        properties.setProperty("maxWait", "30000");
        try{
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        }catch (Exception e){
            e.printStackTrace();
        }
        return dataSource;
    }

    @Bean(name = "jdbcTemplate")
    public JdbcTemplate initJdbcTemplate(){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(initDataSource());
        return jdbcTemplate;
    }

    @Override
    @Bean(name="transactionManager")
    @NonNull
    public TransactionManager annotationDrivenTransactionManager() {
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        //设置事务管理器管理的数据源
        dataSourceTransactionManager.setDataSource(initDataSource());
        return dataSourceTransactionManager;
    }
}

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(TransactionConfig.class);
JdbcTemplate jdbcTemplate = applicationContext.getBean(JdbcTemplate.class);
//事务定义类
TransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
PlatformTransactionManager transactionManager = applicationContext.getBean(PlatformTransactionManager.class);
TransactionStatus status = transactionManager.getTransaction(transactionDefinition);
try{
    //执行SQL语句
    jdbcTemplate.update("insert into t_role(role_name, note) values('role_name_transactionManager', 'note_transactionManager')");
    int x = 1 / 0;
    //提交事务
    transactionManager.commit(status);
}catch(Exception e){
    //回滚事务
    transactionManager.rollback(status);
}

声明式事务

Transactional配置项

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.transaction.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    @AliasFor("transactionManager")
    String value() default "";

    @AliasFor("value")
    String transactionManager() default "";

    String[] label() default {};

    Propagation propagation() default Propagation.REQUIRED;

    Isolation isolation() default Isolation.DEFAULT;

    int timeout() default -1;

    String timeoutString() default "";

    boolean readOnly() default false;

    Class<? extends Throwable>[] rollbackFor() default {};

    String[] rollbackForClassName() default {};

    Class<? extends Throwable>[] noRollbackFor() default {};

    String[] noRollbackForClassName() default {};
}

配置项	含义	备注
value	定义事务管理器	它是Spring IoC容器里的一个Bean id，这个Bean需要实现接口PlatformTransactionManager
transactionManager	同上	同上
isolation	隔离级别	这是一个数据库在多个事务同时存在时的概念。默认值取数据库默认隔离级别
propagation	传播行为	传播行为是方法之间调用的问题，默认值为Propagation.REQUIRED
timeout	超时时间	单位为秒，当超时时，会引发异常，默认会导致事务回滚
readOnly	是否开启只读事务	默认值为false
rollbackFor	回滚事务的异常类定义	也就是只有当方法产生所定义异常时，才回滚事务，否则就提交事务
rollbackForClassName	回滚事务的异常类名定义	同rollbackFor，只是使用类名称定义
noRollbackFor	当产生哪些异常不回滚事务	当产生所定义异常时，Spring将继续提交事务
noRollbackForClassName	同noRollbackFor	同noRollbackFor，只是使用类的名称定义

注意，使用声明式事务需要配置注解驱动：

1	<tx:annotation-driven transaction-manager="transactionManager"/>

使用XML进行配置事务管理器

使用XML配置事务管理器的方法很多，但是也不常用，更多的还是会采用注解式的事务。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"/>
    <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
        <property name="transactionManager" ref="transactionManager"/>
        <!--配置事务属性-->
        <property name="transactionAttributes">
            <props>
                <!--key代表的是业务方法的正则式匹配，而其内容可以配置各类事务定义参数-->
                <prop key="insert*">PROPAGATION_REQUIRED,ISOLATION_READ_UNCOMMITTED</prop>
                <prop key="save*">PROPAGATION_REQUIRED,ISOLATION_READ_UNCOMMITTED</prop>
                <prop key="add*">PROPAGATION_REQUIRED,ISOLATION_READ_UNCOMMITTED</prop>
                <prop key="select*">PROPAGATION_REQUIRED,readOnly</prop>
                <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
                <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
                <prop key="del*">PROPAGATION_REQUIRED,ISOLATION_READ_UNCOMMITTED</prop>
                <prop key="remove*">PROPAGATION_REQUIRED,ISOLATION_READ_UNCOMMITTED</prop>
                <prop key="update*">PROPAGATION_REQUIRED,ISOLATION_READ_UNCOMMITTED</prop>
            </props>
        </property>
    </bean>
    <!--  指明事务拦截器拦截哪些类  -->
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <property name="beanNames"> <!--告诉spirng如何拦截类-->
            <list>
                <value>*ServiceImpl</value> <!--所有关于Service是实现类都会被其拦截-->
            </list>
        </property>
        <property name="interceptorNames"> <!--定义事务拦截器-->
            <list>
                <value>transactionInterceptor</value>
            </list>
        </property>
    </bean>
</beans>

事务定义器

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.transaction;

import org.springframework.lang.Nullable;

public interface TransactionDefinition {
    //传播行为常量定义（7个）
    int PROPAGATION_REQUIRED = 0; //默认传播行为
    int PROPAGATION_SUPPORTS = 1;
    int PROPAGATION_MANDATORY = 2;
    int PROPAGATION_REQUIRES_NEW = 3;
    int PROPAGATION_NOT_SUPPORTED = 4;
    int PROPAGATION_NEVER = 5;
    int PROPAGATION_NESTED = 6;
    //隔离级别定义（5个）
    int ISOLATION_DEFAULT = -1; //默认隔离级别
    int ISOLATION_READ_UNCOMMITTED = 1;
    int ISOLATION_READ_COMMITTED = 2;
    int ISOLATION_REPEATABLE_READ = 4;
    int ISOLATION_SERIALIZABLE = 8;

    int TIMEOUT_DEFAULT = -1; //-1代表永不超时

    //获取传播行为
    default int getPropagationBehavior() {
        return 0;
    }
    //获取隔离级别
    default int getIsolationLevel() {
        return -1;
    }
    //事务超时时间
    default int getTimeout() {
        return -1;
    }
    //是否只读事务
    default boolean isReadOnly() {
        return false;
    }
    //获取事务定义器的名称
    @Nullable
    default String getName() {
        return null;
    }

    static TransactionDefinition withDefaults() {
        return StaticTransactionDefinition.INSTANCE;
    }
}

以上就是关于事务定义器的内容，除了异常的定义，其他关于事务的定义都可以在这里完成，而对于事务的回滚内容，它会议RollbackRuleAttribute和NoRollbackRuleAttribute两个类进行保存，这样在事务拦截器中就可以根据我们所配置的内容来处理事务方面的内容。

声明式事务的约定流程

@Transactional注解可以使用在方法或者类上，在Spring IoC容器初始化时，Spring会读入这个注解或者XML配置的事务信息，并且保存到一个事务定义类里面（TransactionDefinition接口的子类），以备将来使用。当运行时会让Spring拦截注解标注的某一个方法或者类的所有方法。谈到了拦截，可能会想到AOP，Spring也是如此。有了AOP的概念，那么它就会把你编写的代码织入到AOP的流程中，然后给出它的约定。

首先Spring通过事务管理器（PlatformTransactionManager的子类）创建事务，与此同时会把事务定义中的隔离级别、超时时间等属性根据配置内容往事务上设置。而根据传播行为配置采取一种特定的策略，后面会谈到传播行为的使用问题，这是Spring根据配置完成的内容，你只需要配置，无须编码。

然后，启动开发者提供的业务代码，我们知道Spring会通过反射的方式调度开发者的业务代码，但是反射的结果可能是正常返回或者产生异常返回，那么它给的约定是只要发生异常，并且符合事物定义类回滚条件的，Spring就会将数据库事务回滚，否则将数据库事务提交，这也是Spring自己完成的。

你会惊奇地发现，在整个开发过程中，只需要编写业务代码和对事务属性进行配置就可以了，并不需要使用代码干预，工作量比较少，代码逻辑也更为清晰，更有利于维护。

@Autowired
private RoleDao roleDao = null;

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, timeout = 3)
public int insertRole(Role role){
  return roleDao.insert(role);
}

//SpringBoot项目启动入口类
@SpringBootApplication  //SpringBoot核心朱姐，主要用于开启spring自动配置
@EnableTransactionManagement //启动事务
public class Application {}

这里没有数据库的资源打开和释放代码，也没看到数据库提交的代码，只看到了注解@Transactional。它配置了Propagation.REQUIRED的传播行为，这意味着当别的方法调度时，如果存在事务就沿用下来，如果不存在事务就开启新的事务，而隔离级别采用默认的隔离级别，并且设置超时时间为3秒。其他的开发人员只要知道当roleDao的insert方法抛出异常时，Spring就会回滚事务，如果成功，就提交事务。这样Spring就让开发人员主要精力放在业务的开发上，而不是控制数据库的资源和事务上。

但是我们必须清楚的是，这里的神奇原理是Spring AOP技术，而其底层的实现原理是动态代理，也就是只有代理对象相互调用才能想AOP那么神奇。

数据库相关知识

数据库事务ACID特性

原子性（Atomicity）
一致性（Consistency）
隔离性（Isolation）
持久性（Durability）

丢失更新

第一类丢失更新

假设一个场景，一个账户存在互联网消费和刷卡消费，而一对夫妻共用这个账户。老公喜欢刷卡消费，老婆喜欢互联网消费。老公查询余额10000元，请客吃饭消费1000元，提交事务成功，余额9000元；同时老婆查询10000元月，网购1000元，在老公提交事务成功后，突然不想买了，取消购买，回滚事务，余额还是10000元，这是不符合事实的。

第二类丢失更新

同前一节，不同的是，这里老婆也提交事务成功，余额还是9000元，这是不符合事实的。

为了克服事务之间协助的一致性，数据库标准规范中定义了事务之间的隔离级别，来在不同程度上减少出现丢失更新的可能性。

隔离级别

读未提交、读已提交、可重复度、序列化

选择隔离级别和传播行为

选择隔离级别

在互联网应用中，不但要考虑数据库数据的一致性，而且要考虑系统的性能。一般而言，从脏读到序列化，系统性能直线下降。
在大部分场景下，企业会选择读/写提交的方式设置事务。这样既有助于提高并发，又压制了藏独，但是对于数据一致性问题并没有解决。

@Autowired
private RoleDao roleDao = null;

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
public int insertRole(Role role){
  return roleDao.insert(role);
}

当业务并发量不是很大或者根本不需要考虑的情况下，使用序列化隔离级别用以保证数据的一致性，也是一个不错的选择。
总之，隔离级别需要根据并发的大小和性能作出决定，对于并发不打又要保证数据安全性的可以使用序列化的隔离级别，这样就能保证数据库在多事务环境汇总的一致性。

@Autowired
private RoleDao roleDao = null;

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.SERIALIZABLE)
public int insertRole(Role role){
  return roleDao.insert(role);
}

传播行为

传播行为是指方法之间的调用事务策略的问题。在大部分情况下，我们都希望事务能够同时成功或者同时失败。但是也会有例外，比如批次还款，不希望其中一次还款失败而导致整体其他已成功还款的业务回滚。

解决方法是，批次调度还款是产生一个新事务，如果这次异常，只会回滚本次，而不会回滚主事务。

类似这种一个方法调度另外一个方法时，可以对事务的特性进行传播配置，称为传播行为。

传播行为	含义	备注
REQUIRED	当方法调用时，如果不存在当前事务，那么就创建事务；如果之前的方法已经存在事务了，那么就沿用之前的事务	这是Spring默认的传播行为
SUPPORTS	当方法调用时，如果不存在当前事务，那么不启用事务；如果存在当前事务，那么就沿用当前事务	——
MADATORY	方法必须在事务内运行	如果不存在当前事务，那么就抛出异常
REQUIRES_NEW	无论是否存在当前事务，方法都会在新的事务中运行	也就是事务管理器会打开新的事务运行该方法
NOT_SUPPORTED	不支持事务，如果不存在当前事务也不会创建事务；如果存在当前事务，则挂起它，直至该方法结束后才回复当前事务	适用于那些不需要事务的SQL
NEVER	不支持事务，只有在没有事务的环境中才能运行它	如果方法存在当前事务，则抛出异常
NESTED	嵌套事务，也就是调用方法如果抛出异常只回滚自己内部执行的SQL，而不回滚主方法的SQL	它的实现存在两种情况，如果当前数据库支持保存点(savepoint)，那么它就会在当前事务上使用保存点技术；如果发生异常则将方法内执行的SQL回滚到保存点上，而不是全部回滚，否则就等同于REQUIRES_NEW创建新的事务运行方法代码

@Transactional的自调用失效问题

对于静态（static）方法和非public方法，注解@Transactional是失效的。
自调用失效

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.mapper.RoleMapper;
import com.louris.springboot.IoCImpl.service.RoleDataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class RoleDataServiceImpl implements RoleDataService {

    @Autowired
    private RoleMapper roleMapper = null;

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, isolation = Isolation.READ_COMMITTED)
    public int insertRole(Role role) {
        return roleMapper.insertRole(role);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
    public int insertRoleList(List<Role> roleList) {
        int count = 0;
        for(Role role : roleList){
            try{
                //调用自身类的方法，产生自调用问题
                int i = insertRole(role);
                count ++;
            }catch (Exception ex){
                ex.printStackTrace();
            }
        }
        return count;
    }
}

Java HotSpot(TM) 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated in JDK 13 and will likely be removed in a future release.

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  `  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v 2.4.4)

2021-09-21 22:00:04.630 [main] INFO  com.louris.springboot.Application - Starting Application using Java 14.0.2 on WINDOWS-PT43L0L with PID 34280 (D:\SpringBootCourse\001-springboot-first\target\classes started by louris in D:\SpringBootCourse)
2021-09-21 22:00:04.632 [main] DEBUG com.louris.springboot.Application - Running with Spring Boot v2.4.4, Spring v5.3.5
2021-09-21 22:00:04.633 [main] INFO  com.louris.springboot.Application - The following profiles are active: dev
2021-09-21 22:00:05.033 [main] DEBUG o.m.s.boot.autoconfigure.MybatisAutoConfiguration - Searching for mappers annotated with @Mapper
2021-09-21 22:00:05.033 [main] DEBUG o.m.s.boot.autoconfigure.MybatisAutoConfiguration - Using auto-configuration base package 'com.louris.springboot'
2021-09-21 22:00:05.037 [main] DEBUG org.apache.ibatis.logging.LogFactory - Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
2021-09-21 22:00:05.045 [main] DEBUG org.mybatis.spring.mapper.ClassPathMapperScanner - Identified candidate component class: file [D:\SpringBootCourse\001-springboot-first\target\classes\com\louris\springboot\IoCImpl\mapper\RoleMapper.class]
2021-09-21 22:00:05.047 [main] DEBUG org.mybatis.spring.mapper.ClassPathMapperScanner - Creating MapperFactoryBean with name 'roleMapper' and 'com.louris.springboot.IoCImpl.mapper.RoleMapper' mapperInterface
2021-09-21 22:00:05.048 [main] DEBUG org.mybatis.spring.mapper.ClassPathMapperScanner - Enabling autowire by type for MapperFactoryBean with name 'roleMapper'.
2021-09-21 22:00:05.354 [main] INFO  o.s.boot.web.embedded.tomcat.TomcatWebServer - Tomcat initialized with port(s): 8081 (http)
2021-09-21 22:00:05.361 [main] INFO  org.apache.coyote.http11.Http11NioProtocol - Initializing ProtocolHandler ["http-nio-8081"]
2021-09-21 22:00:05.361 [main] INFO  org.apache.catalina.core.StandardService - Starting service [Tomcat]
2021-09-21 22:00:05.361 [main] INFO  org.apache.catalina.core.StandardEngine - Starting Servlet engine: [Apache Tomcat/9.0.44]
2021-09-21 22:00:05.431 [main] INFO  o.a.c.core.ContainerBase.[Tomcat].[localhost].[/] - Initializing Spring embedded WebApplicationContext
2021-09-21 22:00:05.431 [main] INFO  o.s.b.w.s.c.ServletWebServerApplicationContext - Root WebApplicationContext: initialization completed in 757 ms
2021-09-21 22:00:05.587 [main] DEBUG org.mybatis.spring.SqlSessionFactoryBean - Parsed mapper file: 'file [D:\SpringBootCourse\001-springboot-first\target\classes\mapper\RoleMapper.xml]'
2021-09-21 22:00:05.665 [main] INFO  o.s.scheduling.concurrent.ThreadPoolTaskExecutor - Initializing ExecutorService 'applicationTaskExecutor'
2021-09-21 22:00:05.700 [main] DEBUG _.s.web.servlet.HandlerMapping.Mappings -
	o.s.b.a.w.s.e.BasicErrorController:
	{ [/error]}: error(HttpServletRequest)
	{ [/error], produces [text/html]}: errorHtml(HttpServletRequest,HttpServletResponse)
2021-09-21 22:00:05.712 [main] DEBUG _.s.web.servlet.HandlerMapping.Mappings - 'beanNameHandlerMapping' {}
2021-09-21 22:00:05.720 [main] DEBUG _.s.web.servlet.HandlerMapping.Mappings - 'resourceHandlerMapping' {/webjars/ **=ResourceHttpRequestHandler [Classpath [META-INF/resources/webjars/]], / **=ResourceHttpRequestHandler [Classpath [META-INF/resources/], Classpath [resources/], Classpath [static/], Classpath [public/], ServletContext [/]]}
2021-09-21 22:00:05.733 [main] DEBUG o.m.s.boot.autoconfigure.MybatisAutoConfiguration - No org.mybatis.spring.mapper.MapperFactoryBean found.
2021-09-21 22:00:05.777 [main] INFO  org.apache.coyote.http11.Http11NioProtocol - Starting ProtocolHandler ["http-nio-8081"]
2021-09-21 22:00:05.791 [main] INFO  o.s.boot.web.embedded.tomcat.TomcatWebServer - Tomcat started on port(s): 8081 (http) with context path ''
2021-09-21 22:00:05.798 [main] INFO  com.louris.springboot.Application - Started Application in 1.489 seconds (JVM running for 1.972)
2021-09-21 22:00:06.044 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession
2021-09-21 22:00:06.046 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3815146b]
2021-09-21 22:00:06.050 [main] DEBUG o.m.spring.transaction.SpringManagedTransaction - JDBC Connection [1341975886, URL=jdbc:mysql:/ /localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8, MySQL Connector/J] will be managed by Spring
2021-09-21 22:00:06.053 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==>  Preparing: insert into t_role(role_name, note) values(?, ?)  
2021-09-21 22:00:06.067 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==> Parameters: role_name_1(String), note_1(String)
2021-09-21 22:00:06.068 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - <==    Updates: 1
2021-09-21 22:00:06.075 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3815146b]
2021-09-21 22:00:06.075 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Fetched SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3815146b] from current transaction
2021-09-21 22:00:06.075 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==>  Preparing: insert into t_role(role_name, note) values(?, ?)  
2021-09-21 22:00:06.076 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==> Parameters: role_name_2(String), note_2(String)
2021-09-21 22:00:06.077 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - <==    Updates: 1
2021-09-21 22:00:06.077 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3815146b]
2021-09-21 22:00:06.077 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3815146b]
2021-09-21 22:00:06.077 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3815146b]
2021-09-21 22:00:06.077 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3815146b]

出现原因

在insertRoleList方法的实现中，它调用了自身类实现isertRole的方法，而insertRole声明式REQUIRES_NEW的传播行为，也就是每次调用就会产生新的事务运行，但是通过日志可以发现只有一次

1	Create a new SqlSession

说明角色插入两次都使用了同一事务，也就是说，在insertRole上标注的@Transactional失效了，这是一个很容易掉进去的陷阱。

出现这个问题的根本原因在于AOP的实现原理。由于@Transactional的实现原理是AOP，而AOP的实现原理是动态代理，而上述代码是自己调用自己的过程。换句话说，并不存在代理对象的调用，这样就不会产生AOP去为我们设置@Transactional配置的参数，这样就出现了自调用注解失败的问题！

解决方案

（1）可以使用两个服务类，Spring IoC容器中为你生成了RoleService的代理对象，这样就可以使用AOP，且不会出现该问题；
（2）也可以直接从容器中获取RoleService的代理对象，如下所示：

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.mapper.RoleMapper;
import com.louris.springboot.IoCImpl.service.RoleDataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class RoleDataServiceImpl implements RoleDataService {

    @Autowired
    ApplicationContext applicationContext = null;

    @Autowired
    private RoleMapper roleMapper = null;

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, isolation = Isolation.READ_COMMITTED)
    public int insertRole(Role role) {
        return roleMapper.insertRole(role);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
    public int insertRoleList(List<Role> roleList) {
        int count = 0;
        RoleDataService roleDataService = applicationContext.getBean(RoleDataService.class);
        for(Role role : roleList){
            try{
//                //调用自身类的方法，产生自调用问题
//                int i = insertRole(role);
                roleDataService.insertRole(role);
                count ++;
            }catch (Exception ex){
                ex.printStackTrace();
            }
        }
        return count;
    }
}

2021-09-21 22:10:48.580 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession
2021-09-21 22:10:48.582 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6222391a]
2021-09-21 22:10:48.586 [main] DEBUG o.m.spring.transaction.SpringManagedTransaction - JDBC Connection [1745904086, URL=jdbc:mysql:/ /localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8, MySQL Connector/J] will be managed by Spring
2021-09-21 22:10:48.588 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==>  Preparing: insert into t_role(role_name, note) values(?, ?)  
2021-09-21 22:10:48.601 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==> Parameters: role_name_1(String), note_1(String)
2021-09-21 22:10:48.607 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - <==    Updates: 1
2021-09-21 22:10:48.613 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6222391a]
2021-09-21 22:10:48.613 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6222391a]
2021-09-21 22:10:48.613 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6222391a]
2021-09-21 22:10:48.613 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6222391a]
2021-09-21 22:10:48.646 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession
2021-09-21 22:10:48.646 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@129c4d19]
2021-09-21 22:10:48.646 [main] DEBUG o.m.spring.transaction.SpringManagedTransaction - JDBC Connection [321358401, URL=jdbc:mysql:/ /localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8, MySQL Connector/J] will be managed by Spring
2021-09-21 22:10:48.647 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==>  Preparing: insert into t_role(role_name, note) values(?, ?)  
2021-09-21 22:10:48.647 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==> Parameters: role_name_2(String), note_2(String)
2021-09-21 22:10:48.648 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - <==    Updates: 1
2021-09-21 22:10:48.648 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@129c4d19]
2021-09-21 22:10:48.648 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@129c4d19]
2021-09-21 22:10:48.648 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@129c4d19]
2021-09-21 22:10:48.648 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@129c4d19]

典型错误用法的剖析

错误使用Service

互联网往往曹勇模型——视图——控制器来搭建开发环境，因此在Controller中使用Service是十分常见的。
以下代码中，当一个Controller使用Service方法时，如果这个Service标注有@Transactional，那么它就会启用一个事务，而一个Service方法完成后，它就会释放该事务，所以前后两个insertRole的方法时在两个不同的事务中完成的。

List<Role> list = new ArrayList<>();
Role role = new Role();
role.setRoleName("role_name_1");
role.setNote("note_1");

Role role1 = new Role();
role1.setRoleName("role_name_2");
role1.setNote("note_2");

RoleDataService roleDataService = applicationContext.getBean(RoleDataService.class);
roleDataService.insertRole(role);
roleDataService.insertRole(role1);

日志可以证实这一点，明确地说明使用带有事务的Service，当调用时，如果不是调用Service方法，Spring会为你创建对应的数据库事务。如果多次调用，则不再同一个事务中，这会造成不同时提交和回滚不一致的问题。每一个Java EE开发者都要注意这类问题，以避免一些不必要的错误。

2021-09-22 10:14:49.893 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession
2021-09-22 10:14:49.895 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@508ad266]
2021-09-22 10:14:49.899 [main] DEBUG o.m.spring.transaction.SpringManagedTransaction - JDBC Connection [1772358460, URL=jdbc:mysql:/ /localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8, MySQL Connector/J] will be managed by Spring
2021-09-22 10:14:49.901 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==>  Preparing: insert into t_role(role_name, note) values(?, ?)  
2021-09-22 10:14:49.916 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==> Parameters: role_name_1(String), note_1(String)
2021-09-22 10:14:49.918 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - <==    Updates: 1
2021-09-22 10:14:49.924 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@508ad266]
2021-09-22 10:14:49.924 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@508ad266]
2021-09-22 10:14:49.925 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@508ad266]
2021-09-22 10:14:49.925 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@508ad266]
2021-09-22 10:14:49.972 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession
2021-09-22 10:14:49.972 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4a31ed12]
2021-09-22 10:14:49.973 [main] DEBUG o.m.spring.transaction.SpringManagedTransaction - JDBC Connection [593881656, URL=jdbc:mysql:/ /localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8, MySQL Connector/J] will be managed by Spring
2021-09-22 10:14:49.973 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==>  Preparing: insert into t_role(role_name, note) values(?, ?)  
2021-09-22 10:14:49.973 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - ==> Parameters: role_name_2(String), note_2(String)
2021-09-22 10:14:49.974 [main] DEBUG c.l.s.IoCImpl.mapper.RoleMapper.insertRole - <==    Updates: 1
2021-09-22 10:14:49.974 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4a31ed12]
2021-09-22 10:14:49.974 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4a31ed12]
2021-09-22 10:14:49.974 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4a31ed12]
2021-09-22 10:14:49.974 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4a31ed12]

过长时间占用事务

在企业的生产系统中，数据库事务资源是最宝贵的资源之一，使用了数据库事务之后，要及时释放数据库事务。换言之，我们应该尽可能地使用数据库事务资源去完成所需工作，但是在一些工作中需要使用到文件、对外连接等操作，而这些操作往往会占用较长时间，针对这些，如果开发者不注意细节，就很容易出现系统宕机的问题。

以下代码在insertRole方法结束后，Spring才会释放数据库事务资源，也就是说在运行doSomethingForFile方法时，Spring并没有释放数据库事务资源，而等到doSomethingForFile方法运行完成后，返回result后才会关闭数据库资源。

在大型互联网系统中，一个数据库的链接可能也就是50条左右，然而同时并发的请求则可能是成百上千。对于这些请求，大部分的并发请求都在等待50条占有数据库连接资源的文件操作了。加入平均一个doSomethingForFile的操作需要1秒，对于同时出现1000条并发请求的网站，就会出现请求卡顿的状态。因为大部分的请求都在等待数据库事务资源的分配，这是一个糟糕的结果。

@Override
@Transactional(propagation = Propagation.REQUIRES_NEW, isolation = Isolation.READ_COMMITTED)
public int insertRole(Role role) {
    //return roleMapper.insertRole(role);
    int result = roleMapper.insertRole(role);
    //操作一些与数据库无关的操作
    doSomethingForFile()
    return result;
}

正确做法是Controller进行非数据库操作，如下所示，当程序运行完isnertRole方法后，Spring会释放数据库事务资源，而不再占用。对于doSomethingForFile方法而言，已经在一个没有事务的环境中运行了，这样当前的请求就不会长期占用数据库事务资源，使得其他并发的请求被迫等待其释放了。

@RequestMapping("/addRole")
@ResponseBody
public Role addRole(Role role){
    roleService.insertRole(role);
    doSomethingForFild();
    return role;
}

错误捕获异常

模拟一段购买商品的代码，其中ProductService是产品服务类，而TransactionService是记录交易信息，需求显然就是产品减库存和保存交易在同一个事务里面，要么同时成功，要么同时失败，并且假设减库存和保存交易的传播行为都为REQUIRED。

@Autowired
private ProductService productService;

@Autowired
private TransactionService transactionService;

@Override
@Transactional(propagation=Propagation.REQUIRED, isolation=Isolation.READ_COMMITTED)
public int doTranslation(TranslationBean trans){
  int result = 0;
  try{
    //减少库存
    int result = productService.decreaseStock(trans.getProductid(), trans.getQuantity());
    //如果减少库存成功则保存记录
    if(result > 0){
      transactionService.save(trans);
    }
  }catch(Exception ex){
    //自行处理异常代码
    //记录异常日志
    log.info(ex);
  }
  return result;
}

这里的问题是方法已经存在异常了，由于开发者不了解Spring的事务约定，在两个操作的方法里面加入了自己的try…catch…语句，就可能发生这样的结果。当减少库存成功了，但是保存交易信息时失败而发生了异常，此时由于开发者加入了try…catch…语句，所以Spring在数据库事务所约定的流程中再也得不到任何异常信息了，此时Spring就会提交事务，这样就出现了库存减少，而交易记录却没有的糟糕情况。在那些需要大量异常处理的代码中，我们要小心这样的问题。

@Autowired
private ProductService productService;

@Autowired
private TransactionService transactionService;

@Override
@Transactional(propagation=Propagation.REQUIRED, isolation=Isolation.READ_COMMITTED)
public int doTranslation(TranslationBean trans){
  int result = 0;
  try{
    //减少库存
    int result = productService.decreaseStock(trans.getProductid(), trans.getQuantity());
    //如果减少库存成功则保存记录
    if(result > 0){
      transactionService.save(trans);
    }
  }catch(Exception ex){
    //自行处理异常代码
    //记录异常日志
    log.info(ex);
    //自行抛出异常，让Spring事务管理流程获取异常，进行事务管理
    throw new RuntimeException(ex);
  }
  return result;
}

注意throw抛出了一个运行异常，这样在Spring的事务流程汇总，就会捕捉到抛出的这个异常，进行事务回滚，从而保证了产品减库存和交易记录保存的一致性，这才是正确的用法，使用事务时要时刻记住Spring和我们的约定流程。

Spring MVC 框架

Spring MVC的初始化和流程

MVC设计概述

SpringMVC的组件和流程

Spring MVC的核心在于其流程，这是使用Spring MVC框架的基础，Spring MVC是一种基于Servlet的技术，它提供了核心控制器DispatcherServlet和相关的组件，并制定了松散的结构，以适合各种灵活的需要。

首先，Spring MVC框架爱是围绕着DispatcherServlet而工作的，所以这个类是其最为重要的类。从它的名字来看，它是一个Servlet，它可以拦截HTTP发送过来的请求，在Servlet初始化（调用init方法）时，Spring MVC会根据配置，获取配置信息，从而得到统一资源标识符（URI, Uniform Resource Identifier）和处理器（Handler）之间的映射关系（HandlerMapping），为了更加灵活和增强功能，Spring MVC还会给处理器加入拦截器，所以还可以在处理器执行前后加入自己的代码，这样就构成了一个处理器的执行链（HandlerExecutionChain），并且根据上下文初始化视图解析器等内容，当处理器返回的时候就可以通过视图解析器定位视图，然后将数据模型渲染到视图中，用来响应用户的请求了。

当一个请求到来时，DispatcherServlet首先通过请求和事先解析好的HandlerMapping配置，找到对应的处理器（Handler），这样就准备开始运行处理器和拦截器组成的执行链，而运行处理器需要有一个对应的环境，这样它就有了一个处理器的适配器（HandlerAdapter），通过这个适配器就能运行对应的处理器及其拦截器，这里的处理器包含了控制器的内容和其他增强的功能，在处理器返回模型和视图给DispacherServlet后，DispacherServlet就会把对应的视图信息传递给视图解析器（ViewResolver）。注意，这一步取决于是否使用逻辑视图，如果使用逻辑视图，那么视图解析器就会解析它，然后把模型渲染到视图中去，最后响应用户的请求；如果不是逻辑视图，则不会进行处理，而是直接通过视图渲染数据模型。这就是一个Spring MVC完整的流程，它是一个松散的结构，所以可以满足各类请求的需要。

Spring MVC 入门的实例

启动thymeleaf

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

package com.louris.springboot.IoCImpl.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
//@RequestMapping(value = "")
public class IndexController {

    @RequestMapping(value = "/index")
    public ModelAndView index(){
        ModelAndView mv = new ModelAndView();
        mv.setViewName("index");
        return mv;
    }
}

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>Hello, Spring MVC</h1>
</body>
</html>

Spring MVC开发流程详解

在目前的开发过程中，大部分都会采用注解的开发方式，使用注解在Spring MVC中十分简单，主要是以一个注解@Controller标注，一般只需要通过扫描设置，就能将其扫描出来，只是往往还要结合注解@RequestMapping去配置它。@RequestMapping可以配置在类或方法之上，它的作用是指定URI和哪个类（或方法）作为一个处理请求的处理器，为了更加灵活，Spring MVC还定义了处理器的拦截器，当启动Spring MVC的时候，Spring MVC就会去解析@Controller中的@RequestMapping的配置，再结合所配置的拦截器，这样它就会组成多个拦截器和一个控制器的形式，存放到一个HandlerMapping中去。当请求来到服务器，首先是通过请求信息找到对应的handlerMapping，进而可以找到对应的拦截器和处理器，这样就能够运行对应的控制器和拦截器。

配置@RequestMapping

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web.bind.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {
    //请求路径
    String name() default "";

    //请求路径，可以是数组
    @AliasFor("path")
    String[] value() default {};

    //请求路径，数组
    @AliasFor("value")
    String[] path() default {};

    //请求类型，比如是HTTP的GET请求还是POST请求等，HTTP请求枚举取值范围为：GET、HEAD、POST、PUT、PATCH、DELETE、OPTIONS、TRACE，常用的是GET和POST请求
    RequestMethod[] method() default {};

    //请求参数，当请求带有配置的参数时，才匹配处理器
    String[] params() default {};

    //请求头，当HTTP请求头尾配置项时，才匹配处理器
    String[] headers() default {};

    //请求类型为配置类型才匹配处理器
    String[] consumes() default {};

    //处理器之后的响应用户的结果类型，比如{"application/json; charset=UTF-8", "text/plain", "application/*"}
    String[] produces() default {};
}

控制器的开发

获取请求参数

(1)不建议使用Servlet容器所给予的API，因为这样控制器将会依赖于Servlet容器。
Spring MVC会自动解析代码中的方法参数session、request，然后传递关于Servlet容器的API参数，所以是可以获取到的。通过request或者session都可以很容易地得到HTTP请求过来的参数，这固然是一个方法，但并非一个好的方法。
因为如果这样做了，那么对于idnex2方法而言，它就和Servlet容器紧密关联了，不利于扩展和测试。

@RequestMapping(value = "/index2", method = RequestMethod.GET)
public ModelAndView index2(HttpSession session, HttpServletRequest request){
    String idStr = request.getParameter("id");
    Long id = Long.parseLong(idStr);
    ModelAndView mv = new ModelAndView();
    mv.setViewName("index");
    return mv;
}

（2）建议使用@RequestParam注解来获取参数（不写的话，默认与参数名相同）
@RequestParam参数

required，默认true，不允许参数为空

defaultValue，默认值为”\n\t\t\n\t\t\n\uE000\uE001\uE002\n\t\t\t\t\n”，可以修改为想要的内容。
通过注解和一些约定，可以发现index3方法对Servlet API的依赖没有了，它就很容易进行测试和扩展。

@RequestMapping(value ="/index3", method = RequestMethod.GET)
public ModelAndView index3(@RequestParam(value = "ID", required = true) Long id){
    System.out.println("params[id] = " + id);
    ModelAndView mv = new ModelAndView();
    mv.setViewName("index");
    return mv;
}

（3）获取session当中的内容
假设在登录系统已经在Session中设置了userName，那么可以使用@SessionAttribute去从Session中获取对应的数据.

@RequestMapping(value = "/index4", method = RequestMethod.GET)
public ModelAndView index4(@SessionAttribute("userName") String userName){
    System.out.println("session[userName] = " + userName);
    ModelAndView mv = new ModelAndView();
    mv.setViewName("index");
    return mv;
}

实现逻辑和绑定视图

package com.louris.springboot.IoCImpl.controller;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;


@Controller
public class RoleController {
    @Autowired
    @Qualifier(value = "roleServiceImpl")
    private RoleService roleService = null;

    public void printRole(Role role){
        roleService.printRole(role);
    }

    @RequestMapping(value = "getRole", method = RequestMethod.GET)
    public ModelAndView getRole(@RequestParam("id") Long id){
        Role role = roleService.getRole(id);
        ModelAndView mv = new ModelAndView();
        mv.setViewName("roleDetails");
        //给数据模型添加一个角色对象
        mv.addObject("role", role);
        return mv;
    }
}

视图渲染

（1）ModelAndView找到roleDetails.html或者roleDetail.jsp进行渲染

@RequestMapping(value = "getRole", method = RequestMethod.GET)
public ModelAndView getRole(@RequestParam("id") Long id){
    Role role = roleService.getRole(id);
    ModelAndView mv = new ModelAndView();
    mv.setViewName("roleDetails");
    //给数据模型添加一个角色对象
    mv.addObject("role", role);
    return mv;
}

@RequestMapping(value = "getRole", method = RequestMethod.GET)
public String getRole(@RequestParam("id") Long id){
    Role role = roleService.getRole(id);
    ModelAndView mv = new ModelAndView();
    mv.setViewName("roleDetails");
    //给数据模型添加一个角色对象
    mv.addObject("role", role);
    return "roleDetails";
}

（2）Model加入参数，返回Stirng，找到roleDetails.html或者roleDetail.jsp进行渲染

@RequestMapping(value = "getRole2", method = RequestMethod.GET)
public String getRole(@RequestParam("id") Long id, Model model){
    Role role = roleService.getRole(id);
    model.addAttribute("role", role);
    return "roleDetails";
}

(3)不渲染，@Response解析对象，返回json数据

@RequestMapping(value = "getRole3", method = RequestMethod.GET)
@ResponseBody
public Object getRole(@RequestParam("id") Long id, Model model){
    Role role = roleService.getRole(id);
    return role;
}

深入Spring MVC组件开发

控制器接受各类请求参数

接收普通请求参数

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form id="form" action="./commonRoleParams">
    <table>
        <tr>
            <td>角色名称</td>
            <td><input id="roleName" name="roleName" value=""></td>
        </tr>
        <tr>
            <td>备注</td>
            <td><input id="note" name="note"></td>
        </tr>
        <tr>
            <td></td>
            <td align="right"><input type="submit" value="提交"></td>
        </tr>
    </table>
</form>
</body>
</html>

package com.louris.springboot.utils;

public class RoleParams {
    private String roleName;
    private String note;

    public void setNote(String note) {
        this.note = note;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public String getNote() {
        return note;
    }

    public String getRoleName() {
        return roleName;
    }
}

package com.louris.springboot.IoCImpl.controller;

import com.louris.springboot.utils.RoleParams;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping("/params")
public class ParamsController {

    @RequestMapping("/form")
    //@ResponseBody
    public String form(Model model){
        model.addAttribute("message", "asasa");
        return "testTable";
    }

    //接收普通参数
    //提交表单后的url为http://localhost:8081/params/commonRoleParams?roleName=aaa&note=nbbb
    @RequestMapping("/commonParams")
    public ModelAndView commonParams(String roleName, String note){ //接收普通参数，
        System.out.println("roleName => " + roleName);
        System.out.println("note => " + note);
        ModelAndView mv = new ModelAndView();
        mv.setViewName("index");
        return mv;
    }

    //复杂参数需要考虑使用POJO管理这些参数
    //表单提交的参数会通过POJO进行获取，需要注意POJO的属性也要和HTTP请求参数名保持一致
    //这样即使没有任何注解，它们也能够有效传递参数
    @RequestMapping("/commonRoleParams")
    public ModelAndView commonRoleParams(RoleParams roleParams){
        System.out.println("roleName =>" + roleParams.getRoleName());
        System.out.println("note =>" + roleParams.getNote());
        ModelAndView mv = new ModelAndView();
        mv.setViewName("index");
        return mv;
    }
}

使用@RequestParam注解获取参数

@RequestMapping("/commonAnnotationParams")
public ModelAndView commonAnnotationParams(@RequestParam("role_name") String roleName, String note){
    System.out.println("roleName =>" + roleName);
    System.out.println("note =>" + note);
    ModelAndView mv = new ModelAndView();
    mv.setViewName("index");
    return mv;
}

使用URL传递参数

一些网站使用URL的形式传递参数，这符合RESTFul风格。

@Autowired
RoleDataService roleDataService = null;

@RequestMapping("/getRole/{id}")
public ModelAndView getRoleByPathVariable(@PathVariable("id") Long id){
    Role role = roleDataService.getRoleByKey(id);
    System.out.println(role.getRoleName());
    ModelAndView mv = new ModelAndView();
    //绑定数据模型
    mv.addObject(role);
    //设置为JSON视图
    mv.setViewName("index");
    return mv;
}

传递JSON参数

有时候参数的传递还要更多的参数，比如角色的名称和备注，查询可能需要分页参数。

public class PageParams{
  private int start;
  private int limit;
  ...
}

public class RoleParams{
  private String roleName;
  private String note;
  private PageParams pageParams = null; //分页参数
  ...
}

$(document).ready(function(){
  //JSON参数和类RoleParams一一对应
  var data = {
    //角色查询参数
    roleName: 'role',
    note: 'note',
    //分页参数
    pageParms:{
      start: 1
      limit: 20
    }
  };
  //Jquery的post请求
  $.post({
    url: "./params/findRoles",
    //此处需要告知传递参数类型为JSON，不能缺少
    contentType: "application/json"
    //将JSON转化为字符串传递
    data: JSON.stringify(data),
    //成功后的方法
    success: function(result){

    }
  });
});

@RequestMapping("/findRoles")
public ModelAndView findRoles(@ResponseBody RoleParams roleParams){
    List<Role> roleList = roleDataService.findRoles(roleParams);
    ModelAndView mv = new ModelAndView();
    mv.addObject(roleList);
    mv.setViewName("index");
    return mv;
}

接收列表数据和表单序列化

在一些场景下，如果要一次性删除多个角色，那么肯定是想将一个角色编号的数组传递给后台，或需要新增角色，甚至同时新增多个角色。无论如何，这都需要用到Java的集合或者数组去保存对应的参数。

简单数组

$(document).ready(function(){
  //删除角色数组
  var idList = {1, 2, 3};
  //JQuery的post请求
  $.post({
    url: "./params/deleteRoles",
    //将JSON转化为字符串传递
    data: JSON.stringify(idList),
    //指定传递数据类型，不可缺少
    contentType: "application/json",
    //成功后的方法
    success: function(result){

    }
  });
});

@RequestMapping("/deleteRoles")
public ModelAndView deleteRoles(@RequestBody List<Long> idList){
    ModelAndView mv = new ModelAndView();
    //删除角色
    int total = roleDataService.deleteRoles(idList);
    //帮顶视图
    mv.addObject("total", total);
    mv.setViewName("index");
    return mv;
}

POJO数组

$(document).ready(function(){
  //新增角色数组
  var roleList = [
    {roleName: 'role_name_1', note: 'note_1'},
    {roleName: 'role_name_2', note: 'note_2'},
    {roleName: 'role_name_3', note: 'note_3'}
  ];
  //JQuery的post请求
  $.post({
    url: "./params/addRoles",
    //将JSON转化为字符串传递
    data: JSON.stringify(roleList),
    contentType: "application/json",
    //成功后的方法
    success: function(result){

    }
  });
});

@RequestMapping("/deleteRoles")
public ModelAndView deleteRoles(@RequestBody List<Long> idList){
    ModelAndView mv = new ModelAndView();
    //删除角色
    int total = roleDataService.deleteRoles(idList);
    //帮顶视图
    mv.addObject("total", total);
    mv.setViewName("index");
    return mv;
}

表单序列化

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>参数</title>
    <script src="https://code.jquery.com/jquery-3.2.0.js" type="text/javascript"></script>
    <script type="text/javascript">
        $(document).ready(function(){
           $("#commit").click(function () {
               var str = $("form").serialize();
               console.log(str)
                //提交表单
               $.post({
                   url: "/params/serializeTest",
                   //将form数据序列化，传递给后台，则将数据以roleName=xxx&&note=xxx传递
                   data: str,
                   //成功后的方法
                   success: function (result) {

                   }
               });
           });
        });
    </script>
</head>
<body>
<form id="form">
    <table>
        <tr>
            <td>角色名称</td>
            <td><input id="roleName" name="roleName" value=""></td>
        </tr>
        <tr>
            <td>备注</td>
            <td><input id="note" name="note"></td>
        </tr>
        <tr>
            <td></td>
            <td align="right"><input id="commit" type="button" value="提交"></td>
        </tr>
    </table>
</form>
</body>
</html>

@RequestMapping("/serializeTest")
public ModelAndView serializeTest(String roleName, String note){
    System.out.println("roleName =>" + roleName);
    System.out.println("note =>" + note);
    ModelAndView mv = new ModelAndView();
    mv.setViewName("index");
    return mv;
}

重定向

方法1

@RequestMapping("/showRoleJsonInfo")
public ModelAndView showRoleJsonInfo(String roleName, String note){
    System.out.println("xxxxx");
    System.out.println("roleName =>" + roleName);
    System.out.println("note =>" + note);
    ModelAndView mv = new ModelAndView();

    mv.addObject("roleName", roleName);
    mv.addObject("note", note);
    mv.setViewName("index");
    return mv;
}

@RequestMapping("/serializeTest")
public String serializeTest(Model model, String roleName, String note){
    System.out.println("roleName =>" + roleName);
    System.out.println("note =>" + note);
    model.addAttribute("roleName", roleName);
    model.addAttribute("note", note);
    return "redirect:showRoleJsonInfo";
}

方法2

@RequestMapping("/showRoleJsonInfo")
public ModelAndView showRoleJsonInfo(String roleName, String note){
    System.out.println("xxxxx");
    System.out.println("roleName =>" + roleName);
    System.out.println("note =>" + note);
    ModelAndView mv = new ModelAndView();

    mv.addObject("roleName", roleName);
    mv.addObject("note", note);
    mv.setViewName("index");
    return mv;
}

@RequestMapping("/serializeTest")
public ModelAndView serializeTest(Model model, String roleName, String note){
    System.out.println("roleName =>" + roleName);
    System.out.println("note =>" + note);
//        model.addAttribute("roleName", roleName);
//        model.addAttribute("note", note);
//        return "redirect:showRoleJsonInfo";
    ModelAndView mv = new ModelAndView();
    mv.setViewName("redirect:./showRoleJsonInfo");
    return mv;
}

传递参数

重定向如果需要传递参数，需要用到RedirectAttributes类，其有两种常见方法：

addAtribute(), 通过url传递的方式http://locahost:8081?obj=obect
addFlashAttribute(), 将数据放入session中，重定向后删除数据，通过@ModelAttribute注解获取对应参数。

@RequestMapping("/showRoleJsonInfo")
public ModelAndView showRoleJsonInfo(String obj, @ModelAttribute("roleName") String roleName, @ModelAttribute("note") String note){
    System.out.println("xxxxx");
    System.out.println(obj);
    System.out.println("roleName =>" + roleName);
    System.out.println("note =>" + note);
    ModelAndView mv = new ModelAndView();

    mv.addObject("roleName", roleName);
    mv.addObject("note", note);
    mv.setViewName("index");
    return mv;
}

@RequestMapping("/serializeTest")
public String serializeTest(RedirectAttributes ra, String roleName, String note){
    System.out.println("roleName =>" + roleName);
    System.out.println("note =>" + note);
    ra.addAttribute("obj", "object");
    ra.addFlashAttribute("roleName", roleName);
    ra.addFlashAttribute("note", note);
    return "redirect:showRoleJsonInfo";
//        ModelAndView mv = new ModelAndView();
//        mv.setViewName("redirect:./showRoleJsonInfo");
//        return mv;
}

保存并获取属性参数

有时候我们会暂存数据到HTTP的request对象或者Session对象汇总，在开发控制器的时候，有时也需要保存对应的数据到这些对象中去，或者从中获取数据。Spring MVC给予了支持：

@RequestAttribute获取HTTP的请求（request）对象属性值，用来传递给控制器的参数；
@SessionAttribute在HTTP的会话（Session）对象属性值中，用来传递给控制器的参数；
@SessionAttribute可以给它配置一个字符串数组，这个数组对应的是数据模型对应的键值对，然后将这些键值对保存到Session中。

注解@RequestAttribute

//设置请求属性
request.setAttribute("id", 1L);
//转发给控制器
request.getRequestDispatcher("./params/requestAttribute")
       .forward(request, response);

@RequestMapping("requestAttribute")
public ModelAndView reqAttr(@RequestAttribute("id") Long id){
    ModelAndView mv = new ModelAndView();
    System.out.println("id =>" + Long.toString(id));
    mv.setViewName("index");
    return mv;
}

注解@SessionAttribute和注解@SessionAttributes

这两个注解和 HTTP 的会话对象有，在浏览器和服务器保持联系的时候 HTTP 会创
个会话对象，这样可以让我们在和服务器会话期间（请注意这个时间范围）通过它读／
写会话对象的属性，缓存定数据信息。
先来讨论下设置会话属性，在控制器中可以使用注解＠SessionAttributes 来设置对应
的键值对，不过这个注解只能对类进行标注，不能对方法或者参数注它可以配置属性
名称或者属性类型。它的作用是当这个类被注解后， Spring MVC 执行完控制器的逻辑后，
将数据模型中对应的属性名称或者属性类型保存到 TTP Session 对象中。

读取后端设置的session属性

<%@ page import="com.louris.springboot.IoCImpl.beans.pojo.Role" %><%--
  Created by IntelliJ IDEA.
  User: louris
  Date: 2021/9/25
  Time: 16:47
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%
    Role role = (Role) session.getAttribute("role");
    out.println("id = " + role.getId() + "<p/>");

    Long id = (Long) session.getAttribute("id");
    out.println("id = " + id + "<p/>");
%>
</body>
</html>

package com.louris.springboot.IoCImpl.controller;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttribute;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

@Controller
@RequestMapping("/attribute")
//可以配置数据模型的名称和类型，两者取或关系
@SessionAttributes(names = {"id"}, types = {Role.class})
public class AttributeController {

    @RequestMapping("/enter")
    public ModelAndView enter(RedirectAttributes ra, Long id){
        ModelAndView mv = new ModelAndView();
        ra.addAttribute("id", id);
        mv.setViewName("redirect:sessionAttributes");
        return mv;
    }
    @RequestMapping("/sessionAttributes")
    public ModelAndView sessionAttrs(Long id){
        System.out.println("sessionAttributes");
        System.out.println(id);
        ModelAndView mv = new ModelAndView();
        Role role = new Role();
        role.setId(id);
        mv.addObject("role", role); //根据类型，Session将会保存角色信息
        mv.addObject("id", id); //根据名称，Session将会保存id
        mv.setViewName("attribute");
        return mv;
    }
}

运行结果

2021-09-25 17:05:21.298  INFO 12204 --- [nio-8081-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2021-09-25 17:05:21.299  INFO 12204 --- [nio-8081-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2021-09-25 17:05:21.299  INFO 12204 --- [nio-8081-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 0 ms
sessionAttributes
2

1 2	id = 2 id = 2

读取前端设置的session属性

上面是后端设置session属性，现在需要读取前端设置的session属性

<%@ page import="com.louris.springboot.IoCImpl.beans.pojo.Role" %><%--
  Created by IntelliJ IDEA.
  User: louris
  Date: 2021/9/25
  Time: 16:47
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%
    session.setAttribute("id", 1L);
    response.sendRedirect("./sessionAttributes");
%>
</body>
</html>

package com.louris.springboot.IoCImpl.controller;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttribute;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

@Controller
@RequestMapping("/attribute")
//可以配置数据模型的名称和类型，两者取或关系
@SessionAttributes(names = {"id"}, types = {Role.class})
public class AttributeController {

    @RequestMapping("/enter")
    public ModelAndView enter(RedirectAttributes ra, Long id){
        ModelAndView mv = new ModelAndView();
        ra.addAttribute("id", id);
        mv.setViewName("attribute");
        return mv;
    }
    @RequestMapping("/sessionAttributes")
    public ModelAndView sessionAttrs(@SessionAttribute("id") Long id){
        System.out.println("sessionAttributes");
        System.out.println(id);
        ModelAndView mv = new ModelAndView();
        Role role = new Role();
        role.setId(id);
        mv.addObject("role", role); //根据类型，Session将会保存角色信息
        mv.addObject("id", id); //根据名称，Session将会保存id
        mv.setViewName("enter");
        return mv;
    }
}

注解@CookieValue和注解@RequestHeader

从名称而言，这两个注解都很明确，就是从 Cooki BTTP 请求头获取对应的请求信
，它们的用法比较简单，且大同小异。只是对于 Cookie ，用户是可以禁用的，所以在使用的时候需要考虑这个问题

@RequestMapping("/getHeaderAndCookie")
@ResponseBody
public Object testHeaderAndCookie(
        @RequestHeader(value = "User-Agnet", required = false, defaultValue = "attribute")
        String userAgent,
        @CookieValue(value = "JSESSIONID", required = true, defaultValue = "MyJsessionId")
        String jsessionId){
    System.out.println("User-Agent: " + userAgent);
    System.out.println("JSESSIONID: " + jsessionId);
    return "aaaa";
}

2021-09-25 17:38:16.756  INFO 17924 --- [nio-8081-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2021-09-25 17:38:16.756  INFO 17924 --- [nio-8081-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2021-09-25 17:38:16.757  INFO 17924 --- [nio-8081-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms
User-Agent: attribute
JSESSIONID: 03E6F0E6323068266E42A287622E2681

拦截器

拦截器是Spring MVC中强大的控件，它可以在进入处理器之前做一些操作，或者在处理器完成后进行操作，甚至是在渲染视图后进行操作。
SpringMVC会在启动期间就通过@RequestMapping的注解解析URI和处理器的对应关系，在运行的时候通过请求找到对应的HandlerMapping，然后构建HandlerExecutionChain对象，它是一个执行的责任链对象。

拦截器的定义

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web.servlet;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.lang.Nullable;

public interface HandlerInterceptor {
    //在处理器之前执行的前置方法，这样Spring MVC可以进入处理器前处理一些方法了。
    //返回值是boolean类型，会影响后面SpringMVC的流程
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }
    //在处理器之后执行的后置方法，处理器的逻辑完成后运行它。
    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }
    //无论是否产生异常都会在渲染视图后执行的方法。
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

拦截器的执行流程

前置方法 -> 判断是否返回true
true -> 处理器 -> 后置方法 -> 视图解析和渲染视图 -> 完成方法 -> 后续流程
false -> 后续流程

开发拦截器

这里模仿登录拦截，只有登录了才能访问需登录才能访问的页面，如果未登录情况下访问了需登录才能访问的页面，会跳转

自定义登录拦截器

package com.louris.springboot.interceptor;

import com.louris.springboot.model.User;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class UserInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("进入拦截器-------------------");
        //编写业务拦截的规则
        //从session中获取用户的信息
        User usr = (User)request.getSession().getAttribute("user");
        //判断用户是否登录
        if(usr == null){
            //未登录
            response.sendRedirect(request.getContextPath() + "/user/error");
            return false;
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

拦截器配置类

package com.louris.springboot.config;

import com.louris.springboot.interceptor.UserInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration  //定义此类为配置类，即相当于之前的xml配置文件
public class InterceptorConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //要拦截user下的所有访问请求，必须用户登录后才可以访问
        //但是这样拦截的路径中有一些是不需要用户登录也可访问的
        String[] addPathPatterns = {
                "/user/**"
        };  //需要拦截的内容

        String[] excludePathPatterns = {
                "/user/login",
                "/user/out",
                "/user/error"
        }; //需要排除的内容
        //mvc:interceptor bean class=""
        registry.addInterceptor(new UserInterceptor()).addPathPatterns(addPathPatterns).excludePathPatterns(excludePathPatterns);
    }
}

用户登录控制器

package com.louris.springboot.web;

import com.louris.springboot.model.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;

@Controller
@RequestMapping(value = "/user")
public class UserController {

    //用户登录请求
    @RequestMapping(value = "/login")
    @ResponseBody
    public Object login(HttpServletRequest request){
        //将用户信息存放到session中
        User user = new User();
        user.setId(1001);
        user.setUserName("zhangsan");
        request.getSession().setAttribute("user", user);
        return "login SUCCESS";
    }

    //该请求需要用户登录之后才能访问
    @RequestMapping(value = "/center")
    @ResponseBody
    public Object center(){
        return "See Center Message";
    }

    //用户不能登录也能访问
    @RequestMapping(value = "/out")
    @ResponseBody
    public Object out(){
        return "Out see anytime";
    }

    //如果用户未登录访问了需要登录才可以访问的请求，之后会跳转至该请求路径
    @RequestMapping(value = "/error")
    @ResponseBody
    public Object error(){
        return "error";
    }
}

验证表单

在实际工作中，得到数据后的第一步就是检验数据的正确性，如果存在录入上的问题，一般会通过注解校验，发现错误后返回给用户，但是对于一些逻辑上的错误，比如购买金额=购买数量×单价，这样的规则就很难使用注解方式进行验证了，这个时候可以使用Spring所提供的验证器（Validator）规则去验证。

导入依赖

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

POJO

package com.louris.springboot.IoCImpl.beans.pojo;

import com.louris.springboot.aop.interceptors.Interceptor;
import org.springframework.format.annotation.DateTimeFormat;

import javax.validation.constraints.*;
import java.util.Date;

public class Transaction {

    //产品编号
    @NotNull
    private Long productId;

    //用户编号
    @NotNull
    private Long userId;

    //交易日期
    @Future //只能是将来的日期
    @DateTimeFormat(pattern = "yyyy-MM-dd") //日期格式化转换
    @NotNull
    private Date date;

    //价格
    @NotNull
    @DecimalMin(value = "0.1")  //最小值0.1元
    private Double price;

    //数量
    @NotNull
    @Min(1) //最小值为1
    @Max(100) //最大值
    private Integer quantity;

    //交易金额
    @NotNull
    @DecimalMax("500000.00")  //最大金额为5万元
    @DecimalMin("1.00")     //最小交易金额为1元
    private Double amount;

    //邮件
    @Pattern(regexp = "^([a-zA-Z0-9]*[-_]?[a-zA-Z0-9]+)*@" +
            "([a-zA-Z0-9]*[-_]?[a-zA-Z0-9]+)+[\\.][A-Za-z]{2,3}([\\.][A-Za-z]{2})?$", message = "不符合邮件格式")
    private String email;

    //备注
    @Size(min=0, max=256) //0到255个字符
    private String note;

    public void setNote(String note) {
        this.note = note;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public void setAmount(Double amount) {
        this.amount = amount;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public void setProductId(Long productId) {
        this.productId = productId;
    }

    public void setQuantity(Integer quantity) {
        this.quantity = quantity;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getNote() {
        return note;
    }

    public String getEmail() {
        return email;
    }

    public Date getDate() {
        return date;
    }

    public Double getAmount() {
        return amount;
    }

    public Double getPrice() {
        return price;
    }

    public Integer getQuantity() {
        return quantity;
    }

    public Long getProductId() {
        return productId;
    }

    public Long getUserId() {
        return userId;
    }
}

页面

<%--
  Created by IntelliJ IDEA.
  User: louris
  Date: 2021/9/26
  Time: 16:00
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>validate</title>

</head>
<body>
<form action="./annotation">
    <table>
        <tr>
            <td>产品编号：</td>
            <td><input name="productId" id="productId"/></td>
        </tr>
        <tr>
            <td>用户编号：</td>
            <td><input name="userId" id="userId"/></td>
        </tr>
        <tr>
            <td>交易日期：</td>
            <td><input name="date" id="date" /></td>
        </tr>
        <tr>
            <td>价格：</td>
            <td><input name="price" id="price"/></td>
        </tr>
        <tr>
            <td>数量：</td>
            <td><input name="quantity" id="quantity"/></td>
        </tr>
        <tr>
            <td>交易金额：</td>
            <td><input name="amount" id="amount"/></td>
        </tr>
        <tr>
            <td>用户邮件：</td>
            <td><input name="email" id="email"/></td>
        </tr>
        <tr>
            <td>备注：</td>
            <td><textarea id="note" name="note" cols="20" rows="5"></textarea> </td>
        </tr>
        <tr>
            <td colspan="2" align="right"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form>
</body>
</html>

控制器

package com.louris.springboot.IoCImpl.controller;

import com.louris.springboot.IoCImpl.beans.pojo.Transaction;
import org.springframework.stereotype.Controller;
import org.springframework.validation.Errors;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.validation.Valid;
import java.util.List;

@Controller
@RequestMapping("/validate")
public class ValidateController {

    @RequestMapping("/form")
    public ModelAndView form(){
        ModelAndView mv = new ModelAndView();
        mv.setViewName("transaction");
        return mv;
    }
    @RequestMapping("/annotation")
    public ModelAndView annotationValidate(@Valid Transaction transaction, Errors errors){
        //是否存在错误
        if(errors.hasErrors()){
            //获取错误信息
            List<FieldError> errorList = errors.getFieldErrors();
            for(FieldError error:errorList){
                //打印字段错误信息
                System.err.println("field: " + error.getField() + "\t" +
                        "msg: " + error.getDefaultMessage());
            }
        }
        ModelAndView mv = new ModelAndView();
        mv.setViewName("enter");
        return mv;
    }
}

使用验证器

验证器接口

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.validation;

public interface Validator {
    //判断当前验证器是否用于检验clazz类型的POJO
    //true表示启动检验，否则不再检验
    boolean supports(Class<?> var1);

    //检验POJO的合法性
    //var1为POJO请求对象
    //var2为错误信息
    void validate(Object var1, Errors var2);
}

自定义验证器

package com.louris.springboot.utils;


import com.louris.springboot.IoCImpl.beans.pojo.Transaction;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;

public class TransactionValidator implements Validator {

    @Override
    public boolean supports(Class<?> aClass) {
        return Transaction.class.equals(aClass);
    }

    @Override
    public void validate(Object o, Errors errors) {
        Transaction transaction = (Transaction) o;
        //求交易金额和价格×数量的差额
        double dis = transaction.getAmount() - (transaction.getPrice() * transaction.getQuantity());
        //如果差额大于0.01，则认为业务错误
        if(Math.abs(dis) > 0.01){
            //加入错误信息
            errors.rejectValue("amount", null, "交易金额和购买数量与价格不匹配");
        }
    }
}

控制器绑定验证器

package com.louris.springboot.IoCImpl.controller;

import com.louris.springboot.IoCImpl.beans.pojo.Transaction;
import com.louris.springboot.utils.TransactionValidator;
import org.springframework.stereotype.Controller;
import org.springframework.validation.DataBinder;
import org.springframework.validation.Errors;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.View;

import javax.validation.Valid;

import java.util.List;

@Controller
@RequestMapping("/validate")
public class ValidateController {

    @InitBinder
    public void initBinder(DataBinder binder){
        binder.setValidator(new TransactionValidator());
    }

    @RequestMapping("/form")
    public ModelAndView form(){
        ModelAndView mv = new ModelAndView();
        mv.setViewName("transaction");
        return mv;
    }

    @RequestMapping("/annotation")
    public ModelAndView annotationValidate(@Valid Transaction transaction, Errors errors){
        //是否存在错误
        if(errors.hasErrors()){
            //获取错误信息
            List<FieldError> errorList = errors.getFieldErrors();
            for(FieldError error:errorList){
                //打印字段错误信息
                System.err.println("field: " + error.getField() + "\t" +
                        "msg: " + error.getDefaultMessage());
            }
        }
        ModelAndView mv = new ModelAndView();
        mv.setViewName("enter");
        return mv;
    }

}

数据模型

下面的例子中只是在数据模型中加入了数据，但没有把数据模型绑定给视图和模型，这一步是Spring MVC在完成控制器逻辑后，自动绑定的，并不需要我们绑定，也就没有绑定的代码了。

@RequestMapping(value = "getRoleByModelMap", method = RequestMethod.GET)
public ModelAndView getRoleByModelMap(@RequestParam("id") Long id, ModelMap modelMap){
    Role role = roleService.getRole(id);
    ModelAndView mv = new ModelAndView();
    mv.setViewName("roleDetals");
    modelMap.addAttribute("role", role);
    return mv;
}

@RequestMapping(value = "getRoleByModel", method = RequestMethod.GET)
public ModelAndView getRoleByModelMap(@RequestParam("id") Long id, Model model){
    Role role = roleService.getRole(id);
    ModelAndView mv = new ModelAndView();
    mv.setViewName("roleDetals");
    model.addAttribute("role", role);
    return mv;
}

@RequestMapping(value = "getRoleByMv", method = RequestMethod.GET)
public ModelAndView getRoleByMv(@RequestParam("id") Long id, ModelAndView mv){
    Role role = roleService.getRole(id);
    ModelAndView mv = new ModelAndView();
    mv.setViewName("roleDetals");
    mv.addObject("role", role);
    return mv;
}

视图和视图解析器

视图是展示给用户的内容，而在此之前，要通过控制器得到对应的数据模型，如果是非逻辑视图，则不会经过视图解析器定位视图，而是直接将数据模型渲染便结束了；而逻辑视图则要对其进一步解析，以定位真实视图，这就是视图解析器的作用了。而视图则是把从控制器查询回来的数据模型进行渲染，以显示给请求者查看。

视图

视图接口定义

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web.servlet;

import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.lang.Nullable;

public interface View {
    //响应状态属性
    String RESPONSE_STATUS_ATTRIBUTE = View.class.getName() + ".responseStatus";
    //定义数据模型下取出变量路径
    String PATH_VARIABLES = View.class.getName() + ".pathVariables";
    //选择响应内容类型
    String SELECTED_CONTENT_TYPE = View.class.getName() + ".selectedContentType";

    //响应客户端的类型
    @Nullable
    default String getContentType() {
        return null;
    }

    //渲染方法，model是数据模型
    void render(@Nullable Map<String, ?> model, HttpServletRequest var2, HttpServletResponse var3) throws Exception;
}

非逻辑视图

将数据模型转换为一个JSON视图，展现给用户，无须对视图名字再进行下一步的解析。
常见的是MappingJackson2JsonView

@RequestMapping(value ="/getRoleForJson", method = RequestMethod.GET)
public ModelAndView getRoleForJson(@RequestParam("id") Long id){
  ModelAndView mv = new ModelAndView();
  Role role = roleService.getRole(id);
  mv.setView(new MappingJackson2JsonView());
  mv.addObject("role", role);
  return mv;
}

逻辑视图

对于逻辑视图而言它需要一个视图解析器，无论是使用XML或者注解，其根本都是在创建一个视图解析器，通过前缀和后缀加上视图名称就能找到对应的JSP文件，然后把数据模型渲染到JSP文件中，这样便能展现视图给用户了。

@Bean(name ="viewResolver")
public ViewResolver initViewResolver(){
  InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
  viewResolver.setPrefix("/WEB-INF/jsp/");
  viewResolver.setSuffix(".jsp");
  return viewResolver;
}

视图解析器

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web.servlet;

import java.util.Locale;
import org.springframework.lang.Nullable;

public interface ViewResolver {
    @Nullable
    View resolveViewName(String viewName, Locale locale) throws Exception;
}

实例：Excel视图的使用

对于Excel而言，Spring MVC所推荐的是使用AbstractXlsView，它实现了视图接口，从其命名也可以知道它只是一个抽象类，不能生成实例对象。

AbstractXlsView抽象类

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web.servlet.view.document;

import java.io.IOException;
import java.util.Map;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.web.servlet.view.AbstractView;

public abstract class AbstractXlsView extends AbstractView {
    public AbstractXlsView() {
        this.setContentType("application/vnd.ms-excel");
    }

    protected boolean generatesDownloadContent() {
        return true;
    }

    protected final void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
        Workbook workbook = this.createWorkbook(model, request);
        this.buildExcelDocument(model, workbook, request, response);
        response.setContentType(this.getContentType());
        this.renderWorkbook(workbook, response);
    }

    protected Workbook createWorkbook(Map<String, Object> model, HttpServletRequest request) {
        return new HSSFWorkbook();
    }

    protected void renderWorkbook(Workbook workbook, HttpServletResponse response) throws IOException {
        ServletOutputStream out = response.getOutputStream();
        workbook.write(out);
        workbook.close();
    }

    //抽象方法，常见Excel文件
    //model —— Spring MVC数据模型
    //workbook —— POI workbook对象
    protected abstract void buildExcelDocument(Map<String, Object> model, Workbook workbook, HttpServletRequest request, HttpServletResponse response) throws Exception;
}

添加依赖

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>4.1.0</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>4.1.0</version>
</dependency>

定义Excel导出接口

假设需要一个导出所有角色信息的功能，但是将来也许还有其他的导出功能。为了方便，先定义一个接口，这个接口主要是让开发者自定义生成Excel的规则。

package com.louris.springboot.IoCImpl.service;

import org.apache.poi.ss.usermodel.Workbook;

import java.util.Map;

public interface ExcelExportService {
    void makeWorkBook(Map<String, Object> model, Workbook workbook);
}

自定义Excel视图类

package com.louris.springboot.IoCImpl.view;

import com.louris.springboot.IoCImpl.service.ExcelExportService;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.view.document.AbstractXlsView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;

public class ExcelView extends AbstractXlsView {

    //文件名
    private String fileName = null;

    //导出视图自定义接口
    private ExcelExportService excelExportService = null;

    //构造方法1
    public ExcelView(ExcelExportService excelExportService){
        this.excelExportService = excelExportService;
    }

    //构造方法2
    public ExcelView(String viewName, ExcelExportService excelExportService){
        this.setBeanName(viewName);
        this.excelExportService = excelExportService;
    }

    @Override
    protected void buildExcelDocument(Map<String, Object> model, Workbook workbook, HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //没有自定义接口
        if(excelExportService == null){
            throw new RuntimeException("导出服务接口不能为null!!");
        }
        //文件名不为空，为空则使用请求路径中的字符串作为文件名
        if(!StringUtils.isEmpty(fileName)){
            //进行字符转换
            String reqCharset = httpServletRequest.getCharacterEncoding();
            reqCharset = reqCharset == null ? "UTF-8" : reqCharset;
            fileName = new String(fileName.getBytes(reqCharset), "ISO8859-1");
            //设置下面文件名
            httpServletResponse.setHeader("Content-disposition", "attachment;filename=" + fileName);
        }
        //回调接口方法，使用自定义生成Excel文档
        excelExportService.makeWorkBook(model, workbook);
    }

    public void setExcelExportService(ExcelExportService excelExportService) {
        this.excelExportService = excelExportService;
    }

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public ExcelExportService getExcelExportService() {
        return excelExportService;
    }

    public String getFileName() {
        return fileName;
    }
}

角色信息导出控制器

package com.louris.springboot.IoCImpl.controller;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.service.ExcelExportService;
import com.louris.springboot.IoCImpl.service.RoleDataService;
import com.louris.springboot.IoCImpl.service.RoleService;
import com.louris.springboot.IoCImpl.view.ExcelView;
import com.louris.springboot.utils.PageParams;
import com.louris.springboot.utils.RoleParams;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.PushBuilder;
import java.util.List;
import java.util.Map;

@Controller
public class RoleController {
    @Autowired
    @Qualifier(value = "roleDataServiceImpl")
    private RoleDataService roleService = null;

    @RequestMapping(value = "/export", method = RequestMethod.GET)
    public ModelAndView export(){
        //模型和视图
        ModelAndView mv = new ModelAndView();
        //Excel视图，并设置自定义导出接口
        ExcelView ev = new ExcelView(exportService());
        //文件名
        ev.setFileName("所有角色.xlsx");
        //设置SQL后台参数
        RoleParams roleParams = new RoleParams();
        //限制一万条
        PageParams page = new PageParams();
        page.setStart(0);
        page.setLimit(10000);
        roleParams.setPageParams(page);
        //查询
        List<Role> roleList = roleService.findRoles(roleParams);
        //加入数据模型
        mv.addObject("roleList", roleList);
        mv.setView(ev);
        return mv;
    }

    @SuppressWarnings({"unchecked"})
    private ExcelExportService exportService(){
        //使用Lambda表达式自定义导出excel规则
        return (Map<String, Object> model, Workbook workbook) -> {
            //获取用户列表
            List<Role> roleList = (List<Role>) model.get("roleList");
            //生成Sheet
            Sheet sheet = workbook.createSheet("所有角色");
            //加载标题
            Row title = sheet.createRow(0);
            title.createCell(0).setCellValue("编号");
            title.createCell(1).setCellValue("名称");
            title.createCell(2).setCellValue("备注");
            //遍历角色列表，生成一行行的数据
            for(int i = 0; i < roleList.size(); i ++){
                Role role = roleList.get(i);
                int rowIdx = i + 1;
                Row row = sheet.createRow(rowIdx);
                row.createCell(0).setCellValue(role.getId());
                row.createCell(1).setCellValue(role.getRoleName());
                row.createCell(2).setCellValue(role.getNote());
            }
        };
    }
}

上传文件

Spring MVC为上传文件提供了良好的支持。首先Spring MVC的文件上传是通过MultipartRevolver处理的，它只是一个接口，它有两个实现类：

CommonsMultipartResolver：依赖于Apache下的jakarta Common FileUpload项目解析Multipart请求，可以在Spring的各个版本中使用，只是它要依赖于第三方包才得以实现；
StandardServletMultipartResolver：Spring3.1版本后的产物，它依赖于Servlet3.0或者更高版本的实现，它不用依赖第三方包；

配置properties文件

# 配置上传文件
# 是否开启文件上传支持
spring.servlet.multipart.enabled=true
# 文件写入磁盘阈值
spring.servlet.multipart.file-size-threshold=0
# 文件上传临时保存位置
spring.servlet.multipart.location=D:\\JavaTest\\upload
# 单个文件上传的最大大小
spring.servlet.multipart.max-file-size=5MB
# 多个文件上传的最大大小
spring.servlet.multipart.max-request-size=10MB
# 文件是否延迟解析
spring.servlet.multipart.resolve-lazily=false

前端页面

<%--
  Created by IntelliJ IDEA.
  User: louris
  Date: 2021/9/28
  Time: 10:22
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>上传文件</title>
</head>
<body>
<form method="post" content="text/html; charset=UTF-8" action="./uploadMultipartFile" enctype="multipart/form-data">
    <input type="file" name="file" value="请选择上传的文件"/>
    <input type="submit" value="提交"/>
</form>
</body>
</html>

注入MultiPartResolver(SpringBoot无须注入)

在Spring中，既可以通过XML，也可以通过Java去配置MultipartResolver，这里只介绍注解配置方式。
注意，”multipartResolver”是Spring约定好的Bean name不可以修改。

package com.louris.springboot.IoCImpl.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.FileSystemResource;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.multipart.support.StandardServletMultipartResolver;

import java.io.IOException;

@Configuration
public class UploadConfig {
    @Bean(name = "multipartResolver")
    public MultipartResolver initMultipartResolver(){
        return new StandardServletMultipartResolver();
    }
    //需要依赖第三方包
//    @Bean(name = "multipartResolver")
//    public MultipartResolver initMultipartResolver(){
//        //文件上传路径
//        String filePath = "D:\\JavaTest\\upload";
//        //5MB
//        Long singleMax = (long) (5 * Math.pow(2, 20));
//        //10MB
//        Long totalMax = (long) (10 * Math.pow(2, 20));
//        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
//        multipartResolver.setMaxUploadSizePerFile(singleMax);
//        multipartResolver.setMaxUploadSize(totalMax);
//        try{
//            multipartResolver.setUploadTempDir(new FileSystemResource(filePath));
//        }catch (IOException e){
//            e.printStackTrace();
//        }
//        return multipartResolver;
//    }
}

控制器

package com.louris.springboot.IoCImpl.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.view.json.MappingJackson2JsonView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.Part;
import java.io.File;
import java.io.IOException;

@Controller
@RequestMapping("/file")
public class FileController {

    @RequestMapping("/do")
    public ModelAndView doForm(){
        ModelAndView mv = new ModelAndView();
        mv.setViewName("upload");
        return mv;
    }

    @RequestMapping("/upload")
    public ModelAndView upload(HttpServletRequest request){
        //进行转换
        MultipartHttpServletRequest multipartHttpServletRequest = (MultipartHttpServletRequest)request;
        //获得请求上传的文件
        MultipartFile file = multipartHttpServletRequest.getFile("file");
        //设置视图为JSON视图
        ModelAndView mv = new ModelAndView();
        mv.setView(new MappingJackson2JsonView());
        //获取原始文件名
        String fileName = file.getOriginalFilename();
        //目标文件
        File dest = new File(fileName);
        try{
            //保存文件
            file.transferTo(dest);
            //保存成功
            mv.addObject("success", true);
            mv.addObject("msg", "上传文件成功");
        }catch (IllegalStateException | IOException e){
            //保存失败
            mv.addObject("success", false);
            mv.addObject("msg", "上传文件失败");
            e.printStackTrace();
        }
        return mv;
    }

    @RequestMapping("/uploadMultipartFile")
    public ModelAndView uploadMultipartFile(MultipartFile file){
        //设置视图为JSON视图
        ModelAndView mv = new ModelAndView();
        mv.setView(new MappingJackson2JsonView());
        //获取原始文件名
        String fileName = file.getOriginalFilename();
        //目标文件
        File dest = new File(fileName);
        try{
            //保存文件
            file.transferTo(dest);
            //保存成功
            mv.addObject("success", true);
            mv.addObject("msg", "上传文件成功");
        }catch (IllegalStateException | IOException e){
            //保存失败
            mv.addObject("success", false);
            mv.addObject("msg", "上传文件失败");
            e.printStackTrace();
        }
        return mv;
    }

    @RequestMapping("/uploadPart")
    public ModelAndView uploadPart(Part file){
        //设置视图为JSON视图
        ModelAndView mv = new ModelAndView();
        mv.setView(new MappingJackson2JsonView());
        //获取原始文件名
        String fileName = file.getSubmittedFileName();
        //目标文件
        File dest = new File(fileName);
        try{
            //保存文件
            file.write("D:\\JavaTest\\upload\\" + fileName);
            //保存成功
            mv.addObject("success", true);
            mv.addObject("msg", "上传文件成功");
        }catch (IllegalStateException | IOException e){
            //保存失败
            mv.addObject("success", false);
            mv.addObject("msg", "上传文件失败");
            e.printStackTrace();
        }
        return mv;
    }
}

Spring MVC高级应用

Spring MVC的数据转换和格式化

首先当一个请求到达 DispatcherServlet 的时候，需要找到对应的Handler Mapping ，然后根据 HandlerMapping 去找到对应的 HandlerAdapter 执行处理器。处理器在要调用的控制器之前，需要先获取 HTTP 发送过来的信息，然后将其转变为控制器的各种不同类型参数，这就是各类注解能够得到丰富类型参数的原因。它首先用 HTTP消息转换器（HttpMessageConverter ）对消息转换，但是这是个比较原始的转换，它是String类型和文件类型比较简易的转换，它还需要进一步转换才能转换为 POJO 或者其他丰富的参数类型。为了拥有这样的能力， Spring 提供了转换器和格式化器，这样通过注解的信息和参数的类型，它就能够把 HTTP 发送过来的各种消息转换成为控制器所需要的各类参数了。

当处理器处理完了这些参数的转换，它就会进行验证，验证表单的方法在 15 章已经谈及。完成了这些内容，下步就是调用开发者所提供的控制器了，将之前转换成功的参数传递进去，这样我开发的控制器就能够得到丰富的 Java 类型的支持了，进而完成控制器的逻辑，控制器完成了对应的逻辑，返回结果后，处理器如果可以找到对应处理结果类型HttpMessageConverter 的实现类，它就会调用对应的 HttpMessageConverter 的实现类方法。对控制器返回的结果进行 HTTP 转换步不是必须的，可以转换的前提是能够找到对应的转换器在讨论注解＠ResponseBody 会再次看到这个过程，做完这些处理器的功能就完成了。

接下来就是关于视图解析和视图解析器的流程了，在前面的章节我们已经有了详细地阐述。整个过程是比较复杂的，有时候要自定义些特殊的转换规则，比如我们和第合作，合作方可能提供的并不是一良好的 JSON 式，而是一些特殊的规则，这个时候就可能需要使用自定义的消息转换规则，把消息转换为对应的 Java 类型，从而简化开发。

在Java 类型转换之前， Spring MVC 中，为了应对 HTTP 请求，它还定义了HttpMessageConverter ，它是个总体的接口，通过它可以读入 HTT 请求内容。也就是说，在读取 HTTP 请求的参数和内容的时候会先用 HttpMessageConverter 读出，做一次简单转换为 Java 类型，主要是字符串 String ），然后就可以使用各类转换器进行转换了，在逻辑业务处理完成后，还可以通过它把数据转换为响应给用户的内容。对于转换器而言，在 Spring 中分为两大类，一种是由 Converter 接口所定义的，另外种是 GenericConverter ，它们都可以使用注册机注册。注意，它们都是来自于 Spring Core 项目，而非 SpringMVC 项目，它的作用范围是 Java 内部各种类型之间的转换。

HttpMessageConverter和JSON消息转换器

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.http.converter;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.lang.Nullable;

public interface HttpMessageConverter<T> {
    //判断类型是否可读，clazz是类别，而对于mediaType是HTTP类型
    boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);

    //判断类型是否可写，clazz是类别，而对于mediaType是HTTP类型
    boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);

    //对于mediaType是HTTP类型
    List<MediaType> getSupportedMediaTypes();

    default List<MediaType> getSupportedMediaTypes(Class<?> clazz) {
        return !this.canRead(clazz, (MediaType)null) && !this.canWrite(clazz, (MediaType)null) ? Collections.emptyList() : this.getSupportedMediaTypes();
    }

    //读取数据类型，进行转换，clazz是类，而inputMessage是HTTP请求消息
    T read(Class<? extends T> var1, HttpInputMessage var2) throws IOException, HttpMessageNotReadableException;

    //消息写，contentType是HTTP类型，outputMessage是HTTP的应答消息
    void write(T var1, @Nullable MediaType var2, HttpOutputMessage var3) throws IOException, HttpMessageNotWritableException;
}

JSON消息转换类

package com.louris.springboot.IoCImpl.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.HandlerAdapter;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;

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

@Configuration
public class ConvertConfig {
    @Bean(name = "requestMappingHandlerAdapter")
    public HandlerAdapter initRequestMappingHandlerAdapter(){
        //创建RequestMappingHandlerAdapter适配器
        RequestMappingHandlerAdapter requestMappingHandlerAdapter = new RequestMappingHandlerAdapter();
        //HTTP JSON转换器
        MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter();
        //http类型支持为JSON类型
        MediaType mediaType = MediaType.APPLICATION_JSON_UTF8;
        List<MediaType> mediaTypes = new ArrayList<>();
        mediaTypes.add(mediaType);
        //加入转换器的支持类型
        mappingJackson2HttpMessageConverter.setSupportedMediaTypes(mediaTypes);
        //往适配器加入JSON转换器
        requestMappingHandlerAdapter.getMessageConverters().add(mappingJackson2HttpMessageConverter);
        return requestMappingHandlerAdapter;
    }
}

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="messageConverters">
        <list>
            <ref bean="jsonConverter"/>
        </list>
    </property>
</bean>
<bean id="jsonConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
    <property name="supportedMediaTypes">
        <list>
            <value>application/json;charset=UTF-8</value>
        </list>
    </property>
</bean>

@ResponseBody注解

通过注解@ResponseBody将标记Spring MVC，将响应结果转变为JSON，这样在控制器返回结果后，它会通过类型判断找到MappingJackson2HttpMessageConverter实例，进而在处理器内转变为JSON，从而满足JSON的转换的要求。

@RequestMapping("/json")
@ResponseBody
public Role getRole(){
    Role role = new Role();
    role.setId(1L);
    role.setRoleName("John");
    role.setNote("Note!!!");
    return role;
}

一对一转换器（Converter）

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.core.convert.converter;

import org.springframework.lang.Nullable;
import org.springframework.util.Assert;

@FunctionalInterface
public interface Converter<S, T> {
    @Nullable
    T convert(S var1); //S为源类型，T为目标类型

    default <U> Converter<S, U> andThen(Converter<? super T, ? extends U> after) {
        Assert.notNull(after, "After Converter must not be null");
        return (s) -> {
            T initialResult = this.convert(s);
            return initialResult != null ? after.convert(initialResult) : null;
        };
    }
}

Spring Core项目的部分转换器

转换器	说明
CharacterToNumber	将字符转换为数字
IntegerToEnum	将整数转换为枚举类型
ObjectToStringConverter	将对象转换为字符串
SerializingConverter	序列化转换器
DeserializingConverter	反序列化转换器
StringToBooleanConverter	将字符串转换为布尔值
StringToEnum	将字符串转换为枚举
StringToCurrencyConverter	将字符串转换为金额
EnumToStringConverter	将枚举转化为字符串

通过HttpMessageConverter把HTTP的消息读出后，Spring MVC就开始使用这些转换器来将HTTP的信息，转化为控制器的参数，这就是能在控制器上获得各类参数的原因。大部分情况下，Spring MVC所提供的功能，能够满足一般的需求，但是有时候我们需要进行自定义转化规则，这当然也不会太困难，只要实现接口Converter，然后注册给对应的转换服务类就可以了。

自定义SpringToRole转换器

@Component注解将bean注册给IoC容器，Spring MVC就会自动进行converter的注册

package com.louris.springboot.utils;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Component
public class StringToRoleConverter implements Converter<String, Role> {

    /**
     *
     * @param str "{id}-{role_name}-{note}"格式
     * @return
     */
    @Override
    public Role convert(String str) {
        //空串
        if(StringUtils.isEmpty(str)){
            return null;
        }
        //不包含指定字符
        if(!str.contains("-")){
            return null;
        }
        String[] arr = str.split("-");
        //字符串长度不对
        if(arr.length != 3){
            return null;
        }
        System.out.println("convert");
        Role role = new Role();
        role.setId(Long.parseLong(arr[0]));
        role.setRoleName(arr[1]);
        role.setNote(arr[2]);
        return role;
    }
}

控制器

@RequestMapping("/updateRole")
@ResponseBody
public Map<String, Object> updateRole(Role role) {
    Map<String, Object> result = new HashMap<>();
    System.out.println(role.toString());
    //更新角色
    result.put("msg", "更新成功");
    return result;
}

运行结果

1 2	convert Role{id=1, roleName='role_name_1', note='aaaa'}

数组和集合转换器 GenericConverter

一对一的转换器只能从一种类型转换成另一种类型，不能进行一对多转换，比如把String转换为List或者String[]，甚至是List。

为了克服这个问题，Spring Core项目还加入了另外一个转换器结构GenericConverter，它能够满足数组和集合转换的要求。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.core.convert.converter;

import java.util.Set;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;

public interface GenericConverter {
    //返回可接受的转化类型
    @Nullable
    Set<GenericConverter.ConvertiblePair> getConvertibleTypes();

    //转换方法
    @Nullable
    Object convert(@Nullable Object var1, TypeDescriptor var2, TypeDescriptor var3);

    //可转换匹配类
    public static final class ConvertiblePair {
        private final Class<?> sourceType; //源类型
        private final Class<?> targetType; //目标类型

        public ConvertiblePair(Class<?> sourceType, Class<?> targetType) {
            Assert.notNull(sourceType, "Source type must not be null");
            Assert.notNull(targetType, "Target type must not be null");
            this.sourceType = sourceType;
            this.targetType = targetType;
        }

        public Class<?> getSourceType() {
            return this.sourceType;
        }

        public Class<?> getTargetType() {
            return this.targetType;
        }

        public boolean equals(@Nullable Object other) {
            if (this == other) {
                return true;
            } else if (other != null && other.getClass() == GenericConverter.ConvertiblePair.class) {
                GenericConverter.ConvertiblePair otherPair = (GenericConverter.ConvertiblePair)other;
                return this.sourceType == otherPair.sourceType && this.targetType == otherPair.targetType;
            } else {
                return false;
            }
        }

        public int hashCode() {
            return this.sourceType.hashCode() * 31 + this.targetType.hashCode();
        }

        public String toString() {
            return this.sourceType.getName() + " -> " + this.targetType.getName();
        }
    }
}

在Spring MVC中，这是一个比较底层的接口，为了进行类型匹配判断，还定义了另外一个接口：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.core.convert.converter;

import org.springframework.core.convert.TypeDescriptor;

public interface ConditionalConverter {
    //如果返回true，才进行下一步转换
    boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType);
}

为了整合原有接口GenericConverter，有了一个新的接口：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.core.convert.converter;

public interface ConditionalGenericConverter extends GenericConverter, ConditionalConverter {
}

基于该接口，Spring Core开发了不少的实现类，这些实现类都会注册到ConversionService对象里，通诺ConditioanlConverter的matches进行匹配。如果可以匹配，则会调用convert方法进行转换，它能够提供各种对数组和集合的转换。

StringToArrayConverter

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.core.convert.support;

import java.lang.reflect.Array;
import java.util.Collections;
import java.util.Set;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.core.convert.converter.ConditionalGenericConverter;
import org.springframework.core.convert.converter.GenericConverter.ConvertiblePair;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

final class StringToArrayConverter implements ConditionalGenericConverter {
    //转换服务类
    private final ConversionService conversionService;

    //构造方法
    public StringToArrayConverter(ConversionService conversionService) {
        this.conversionService = conversionService;
    }

    //可接受的类型
    public Set<ConvertiblePair> getConvertibleTypes() {
        //确定转换类型
        return Collections.singleton(new ConvertiblePair(String.class, Object[].class));
    }

    //查找是否存在Converter支持转换，如果不使用系统的，那么需要自己注册
    public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
        return ConversionUtils.canConvertElements(sourceType, targetType.getElementTypeDescriptor(), this.conversionService);
    }

    //转换方法
    @Nullable
    public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
        if (source == null) {
            return null;
        } else {
            //源数据
            String string = (String)source;
            //逗号分隔字符串
            String[] fields = StringUtils.commaDelimitedListToStringArray(string);
            TypeDescriptor targetElementType = targetType.getElementTypeDescriptor();
            Assert.state(targetElementType != null, "No target element type");
            //转换目标
            Object target = Array.newInstance(targetElementType.getType(), fields.length);
            //遍历数组
            for(int i = 0; i < fields.length; ++i) {
                String sourceElement = fields[i];
                //使用conversionService做类型转换，要求我们使用一个自定义或者Spring Core的Converter
                Object targetElement = this.conversionService.convert(sourceElement.trim(), sourceType, targetElementType);
                Array.set(target, i, targetElement);
            }

            return target;
        }
    }
}

首先，创建StringToArrayConverter对象需要一个ConversionService对象，而getConvertibleTypes方法则是可以自定义的类型，matches方法匹配类型，通过源类型和目标类型判定使用何种Converter能够转换，那么convert方法用于完成对字符串和数字的转换。在大部分情况下，我们都不需要自定义ConditionalGenericConverter实现类，只需要使用Spring MVC提供的便可以了。

由于需要使用一个定义好的Converter，所以利用之前的转换器，按照StringToArrayConverter对象的逻辑，每一个数组的元素都需要用逗号分隔，所以在原有StringToRoleConverter的规则上，让每一个角色对象的传递加入一个逗号分隔便可以了。

@RequestMapping("/updateRole")
@ResponseBody
public Map<String, Object> updateRole(@RequestParam(required = false) Role[] roles) {
    Map<String, Object> result = new HashMap<>();
    for(Role role:roles){
        System.out.println(role.toString());
    }
    //更新角色
    result.put("msg", "更新成功");
    return result;
}

convert
convert
Role{id=1, roleName='role_name_1', note='aaaa'}
Role{id=2, roleName='role_name_1', note='aaaa'}

使用格式化器（Formatter）

有些数据需要格式化，比如说金额、日期等。传递期格 yyyy-MM-dd 或者 yyyy-MM-dd hh ss rnrn ，这些是需要格式化的，对于金额也是如此，比如1万元币，正式场合往往要写作￥10000.00这些都要求字符串按一定的格式转为日期或者金额。为了对这些场景做出支持，Spring Context提供了相关的Formatter。它需要实现一个接口——Formatter，而Formatter又扩展了两个接口Printer和Parser。

在Spring内部用得比较多的两个注解是@DateTimeFormat和@NumberFormat，在客户端显示需要使用相关的标签。

注解参数

<%--
  Created by IntelliJ IDEA.
  User: louris
  Date: 2021/9/29
  Time: 16:23
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charste=UTF-8">
    <title>Title</title>
</head>
<body>
<form id="form" action="./format">
    <table>
        <tr>
            <td>日期</td>
            <td><input id="date" name="date1" type="text" value="2017-06-01"/></td>
        </tr>
        <tr>
            <td>金额</td>
            <td><input id="amount" name="amount1" type="text" value="123,000.00"></td>
        </tr>
        <tr>
            <td></td>
            <td align="right"><input id="commit" type="submit" value="提交"/></td>
        </tr>
    </table>
</form>
</body>
</html>

@RequestMapping("/format")
public ModelAndView format(@RequestParam("date1") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)Date date,
                           @RequestParam("amount1") @NumberFormat(pattern = "#,###.##") Double amount){
    ModelAndView mv = new ModelAndView();
    System.out.println(date.toString());
    System.out.println(amount.toString());
    mv.addObject("date", date);
    mv.addObject("amount", amount);
    mv.setViewName("enter");
    return mv;
}

注解类变量

package com.louris.springboot.IoCImpl.beans.pojo;

import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.format.annotation.NumberFormat;

import java.math.BigDecimal;
import java.util.Date;

public class FormatPojo {
    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
    private Date date1;

    @NumberFormat(pattern = "##,###.00")
    private BigDecimal amount1;

    public void setAmount1(BigDecimal amount1) {
        this.amount1 = amount1;
    }

    public void setDate1(Date date1) {
        this.date1 = date1;
    }

    public BigDecimal getAmount1() {
        return amount1;
    }

    public Date getDate1() {
        return date1;
    }
}

@RequestMapping("/formatPojo")
public ModelAndView format(FormatPojo pojo){
    ModelAndView mv = new ModelAndView();
    System.out.println(pojo.getDate1().toString());
    System.out.println(pojo.getAmount1().toString());
    mv.setViewName("enter");
    return mv;
}

为控制器添加通知

与Spring AOP一样，Spring MVC也能够给控制器加入通知，它主要涉及4个注解：

@ControllerAdvice，主要作用于类，用以标识全局性的控制器的拦截器，它将应用于对应的控制器；
@InitBinder，是一个允许构建POJO参数的方法，允许在构造控制器参数的时候，加入一定的自定义控制；
@ExceptionHandler，通过它可以注册一个控制器异常，使用当控制器发生注册异常时，就会跳转到该方法上；
@ModelAttribute，是一种针对于数据模型的注解，它先于控制器方法运行，当标注方法返回对象时，它会保存到数据模型中。

package com.louris.springboot.utils;

import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.ui.Model;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;

import java.text.SimpleDateFormat;
import java.util.Date;

@ControllerAdvice(basePackages = {"com.louris.springboot.IoCImpl.controller"})
public class CommonControllerAdvice {

    //定义HTTP对应参数处理规则
    @InitBinder
    public void initBinder(WebDataBinder binder){
        //针对日期类型的格式化，其中CustomDateEditor是客户自定义编辑器
        //它的boolean参数表示是否允许为空
        binder.registerCustomEditor(Date.class,
                new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), false));
    }

    //处理数据模型，如果返回对象，则该对象会保存在数据模型中
    @ModelAttribute
    public void populateModel(Model model){
        model.addAttribute("projectName", "springboot of louris");
    }

    //异常处理，使得被拦截的控制器方法发生异常时，都能用相同的视图响应
    @ExceptionHandler(Exception.class)
    public String exception(){
        return "exception";
    }
}

首先，注解＠ControllerAdvice 己经标记了＠Component ，所以标注它， SpringMVC扫描的时候就会将其放置到 IoC 容器中，而它的属性 basePackages 则是指定拦截的控制器然后，通过注解＠InitBinder 可以获得个参数一－WebDataBinder，它是个可以指定 POJO参数属性转换的数据绑定，这里使用了关于日期 CustomDateEditor ，并且指定格式为yyyy-MM-dd ，它还允许自定义验证器，在第 15 章看到了这个过程，它的作用是允许参数的转换和验证器进行自定义。这样被拦截的控制器关于日期对象的参数，都会被它处理，就不需要我们自己制定 ormatter 了。再次，＠ModelAttribute 是关于数据模型的，它会在进入控制器方法前运行，加入一个数据模型键值对 projectName”－ chapter! 。最后@ExceptionHandler 的作用是制定被拦截的控制器发生异常后，如果异常匹配，就会使用该方法处理，返回字符串 exception”，那它就会找到对应的异常 JSP 去响应，这样就可以避免异常页面的不友好。

而事实上，控制器也可以使用@InitBinder、@ExceptionHandler、@ModelAttribute。注意，它只对于当前控制器有效

@Controller
public class RoleController {
    @Autowired
    @Qualifier(value = "roleDataServiceImpl")
    private RoleDataService roleService = null;

    @ModelAttribute("role")
    public Role initRole(@RequestParam(value = "id", required = false) Long id){
        //判断id是否为空
        if(id == null || id < 1){
            return null;
        }
        Role role = roleService.getRoleByKey(id);
        return role;
    }

    @RequestMapping(value = "getRoleFromModelAttribute")
    @ResponseBody
    public Role getRoleFromModelAttribute(@ModelAttribute("role") Role role){
        return role;
    }
}

注意，这个控制器并不在注解＠ControllerAdvice 所扫描的包内，所以不会被公共通知所拦截，它内部的注解@ModelAttribute 只是针对当前控制器本身。它所注解的方法会在控制器之前运行。
这里定义变量名为 role ，这样在运行这个方法之后，返回查询的角色对象，系统就会把返回的角色对象以键 role 保存到数据模型。
getRoleFromModelAttribute 方法的角色参数也只需要注解＠ModelAttrib1 通过变量名 role 取出即可，这样就完成了参数传递.

处理异常

控制器的通知注解@ExceptionHandler 可以处理异常，这点之前我们己经讨论过。此外，SpringMVC 还提供了其他的异常处理机制，通过使用它们可以获取更为精确的信息，从而为定位问题带来方便。在默认的情况下， pring 会将自身产生的异常转换为合适的状态码，通过这些状态码可以进一步确定异常发生的原因，便于找到对应的问题

Spring异常	状态码	备注
BindException	400-Bad Request	数据绑定异常
ConversionNotSupportedException	500-Internal Server Error	数据类型转换异常
HttpMediaTypeNotSupportedException	406-Not Acceptable	HTTP媒体类型不可接受异常
HttpMediaTypeNotSupportedException	415-Unsupported Media Type	HTTP媒体类型不支持异常
HttpMessageNotReadableException	400-Bad Request	HTTP消息不可读异常
HttpMessageNotWritableException	500-Internal Server Error	HTTP消息不可写异常
HttpRequestMethodNotSupportedException	405-Method Not Allowed	HTTP请求找不到处理方法异常，往往是HandlerMapping找不到控制器或其方法响应
MethodArgumentNotValidException	400-Bad Request	控制器方法参数无效异常，一般是参数方面的问题
MissingServletRequestParameterException	400-Bad Request	缺失参数异常
MissingServletRequestPartException	400-Bad Request	方法中表明了采用“multipar/form-data”请求，而实际不是该请求
TypeMismatchException	400-Bad Request	当设置一个POJO属性的时候，发现类型不对

自定义异常

package com.louris.springboot.utils;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

//新增Spring MVC的异常映射，code代表异常映射码，而reason则代表异常原因
@ResponseStatus(code = HttpStatus.NOT_FOUND, reason = "找不到角色信息异常！")
public class RoleException extends RuntimeException{
    private static final long serialVersionUID = 5040949196309781680L;
}

@RequestMapping("notFound")
@ResponseBody
public Role notFound(Long id){
    Role role = roleService.getRoleByKey(id);
    //找不到角色信息抛出RoleException
    if(role == null){
        throw new RoleException();
    }
    return role;
}

//当前控制器发生RoleException异常时，进入该方法
@ExceptionHandler(RoleException.class)
public String handlerRoleException(RoleException e){
    //返回指定的页面，避免不友好
    return "exception";
}

国际化

有时候可能需要国际化，比如开发一个需要提供中文和英文的网站，特别是外资企业更是如此，国际化一般分为语言、时区和国家等信息。

概述

DispatcherServlet会解析一个LocaleResolver接口对象，通过它来决定用户区域（User Locale），读出对应用户系统设定的语言或者用户选择的语言，以确定其国际化。注意，对于DispatcherServlet而言，只能注册一个LocaleResolver接口对象。LocaleContextResolver，能够处理一些用户区域上的问题，包括语言和时区的问题。

AcceptHeaderLocaleResolver：Spring默认的区域解析器，它通过检验HTTP请求的accept-language头部来解析区域。这个头部是由用户的web浏览器根据底层操作系统的区域设置进行设定。注意，这个区域解析器无法改变用户的区域，因为它无法修改用户操作系统的区域设置，所以它并不需要开发，因此没进一步讨论的必要；
FixedLocaleResolver：使用固定Locale国际化，不可修改Locale，这个可以由开发者提供固定的规则，一般不用，本书不再讨论它；
CookieLocaleResolver：根据Cookie数据获取国际化数据，由于用户禁止Cookie或者没有设置，如果是这样，它会根据accept-language HTTP头部确定默认区域；
SessionLocaleResolver：根据Session进行国际化，也就是根据用户Session的变量读取区域设置，所以它是可变的。如果Session也没有设置，那么它也会使用开发者设置默认的值。

只有CookieLocaleResolver和SessionLocaleResolver才能通过Cookie或者Session去修改国际化，而另两个是固定的，所以现实中使用得多的是CookieLocaleResolver和SessionLocaleResolver。

MessageSource接口

如何加载国际化文件的问题，MessageSource接口是Spring MVC为了加载消息所设置的接口。

StaticMessageSource类是一种静态的消息
DelegatingMessageSource实现的是一个代理的功能，这两者在实际应用中使用并不多
ResourceBundleMessageSource使用的是JDK提供的ResourceBundle，它只能把文件放置在对应的类路径下。它不具备热加载的功能，也就是需要重启系统才能重新加载它。
ReloadableResourceBundleMessageSource更为灵活，它可以把属性文件放置在任何地方，可以在系统不重启的情况下

注意”messageSource”是一个默认约定的名称，不能修改。

package com.louris.springboot.IoCImpl.config;

import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ReloadableResourceBundleMessageSource;
import org.springframework.context.support.ResourceBundleMessageSource;

@Configuration
public class InternationalConfig {
    @Bean(name = "messageSource")
    public MessageSource initMessageSource(){
        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
        messageSource.setDefaultEncoding("UTF-8");
        messageSource.setBasename("msg");
        return messageSource;
    }

    @Bean(name = "messageSource")
    public MessageSource initMessageSource(){
        ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();
        messageSource.setDefaultEncoding("UTF-8");
        messageSource.setBasename("classpath:msg");
        //缓存3600秒，相当于1小时，然后重新刷新
        messageSource.setCacheSeconds(3600);
        //缓存3600 × 1000毫秒，相当于1小时，然后重新刷新
        messageSource.setCacheMillis(3600 * 1000);
        return messageSource;
    }
}

CookieLocaleResolver和SessionLocaleResolver

只是对于 Cookie 用户可以进行删除甚至禁用，使得其安全性难以得到保证，导致大量的使用默认值，也许这些并不是用户所期待的。为了避免这个问题，一般用得更多的是 SessionLocaleResolver ，它是基于 Session 实现的，具有更高的可靠性。
注意，”localeResolver”也是一个约定的名称。

@Bean(name = "localeResolver")
public LocaleResolver initCookieLocaleResolver(){
    CookieLocaleResolver resolver = new CookieLocaleResolver();
    //cookie名称
    resolver.setCookieName("lang");
    //cookie超时秒数
    resolver.setCookieMaxAge(1800);
    //默认使用简体中文
    resolver.setDefaultLocale(Locale.SIMPLIFIED_CHINESE);
    return resolver;
}

@Bean(name = "localeResolver")
public LocaleResolver initCookieLocaleResolver(){
    SessionLocaleResolver resolver = new SessionLocaleResolver();
    //默认使用简体中文
    resolver.setDefaultLocale(Locale.SIMPLIFIED_CHINESE);
    return resolver;
}

当然以上都可以用xml进行配置，自己查。

国际化拦截器（LocaleChangeInterceptor）

package com.louris.springboot.IoCImpl.config;

import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ReloadableResourceBundleMessageSource;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.i18n.CookieLocaleResolver;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;

import java.util.Locale;

@Configuration
public class InternationalConfig implements WebMvcConfigurer {
    @Bean(name = "messageSource")
    public MessageSource initMessageSource(){
        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
        messageSource.setDefaultEncoding("UTF-8");
        messageSource.setBasename("msg");
        return messageSource;
    }

//    @Bean(name = "messageSource")
//    public MessageSource initMessageSource(){
//        ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();
//        messageSource.setDefaultEncoding("UTF-8");
//        messageSource.setBasename("classpath:msg");
//        //缓存3600秒，相当于1小时，然后重新刷新
//        messageSource.setCacheSeconds(3600);
//        //缓存3600 × 1000毫秒，相当于1小时，然后重新刷新
//        messageSource.setCacheMillis(3600 * 1000);
//        return messageSource;
//    }

    @Bean(name = "localeResolver")
    public LocaleResolver initCookieLocaleResolver(){
        CookieLocaleResolver resolver = new CookieLocaleResolver();
        //cookie名称
        resolver.setCookieName("lang");
        //cookie超时秒数
        resolver.setCookieMaxAge(1800);
        //默认使用简体中文
        resolver.setDefaultLocale(Locale.US);
        return resolver;
    }

//    @Bean(name = "localeResolver")
//    public LocaleResolver initCookieLocaleResolver(){
//        SessionLocaleResolver resolver = new SessionLocaleResolver();
//        //默认使用简体中文
//        resolver.setDefaultLocale(Locale.SIMPLIFIED_CHINESE);
//        return resolver;
//    }


    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        LocaleChangeInterceptor interceptor = new LocaleChangeInterceptor();
        interceptor.setParamName("language");
        registry.addInterceptor(interceptor).addPathPatterns("/**");
    }
}

package com.louris.springboot.IoCImpl.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class MessageController {
    @RequestMapping("/msgpage")
    public String page(Model model){
        return "locale";
    }
}

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags" %>
<%--
  Created by IntelliJ IDEA.
  User: louris
  Date: 2021/9/30
  Time: 10:41
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h2>
    <%--  找到属性文件变量名为welcome的配置  --%>
    <spring:message code="welcome"/>
</h2>
Locale: ${pageContext.response.locale}
</body>
</html>

两个配置文件：
msg_en_US.propertires

1	welcome=the project name is springboot

msg_en_CN.properties

1	welcome=项目名为SpringBoot

Redis应用

Redis概述

缓存常用的数据
需要高速读/写的场合使用它快速读/写

Redis基本安装和使用

Windows下安装Redis

https://github.com/microsoftarchive/redis/releases下载Redis解压后
新建文件startup.cmd

1	redis-server redis.windows.conf

Linux下安装Redis

wget http://download.redis.io/releases/redis-6.2.6.tar.gz
tar -zvxf redis-6.2.6.tar.gz
cd redis-6.2.6
make

启动

1	./src/redis-server

另一个客户端启动命令行窗口

1	./src/redis-cli

Redis的Java API

在Java程序中使用Redis

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisTest {

    public static void main(String[] args){
        Jedis jedis = connectionPool(); //simpleConnection();
        int i = 0; //记录操作次数
        try{
            long start = System.currentTimeMillis();
            while(true){
                long end = System.currentTimeMillis();
                if(end - start >= 1000) break;
                i ++;
                jedis.set("test" + i, i + "");
            }
        }finally { //关闭连接
            jedis.close();
        }
        System.out.println("redis 每秒操作：" + i + "次"); //打印1秒内对Redis的操作次数
    }

    private static Jedis simpleConnection(){
        Jedis jedis = new Jedis("localhost", 6379); //连接redis
        //jedis.auth("passsword"); //如果需要密码
        return jedis;
    }

    private static Jedis connectionPool(){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //最大空闲数
        poolConfig.setMaxIdle(50);
        //最大连接数
        poolConfig.setMaxTotal(100);
        //最大等待毫秒数
        poolConfig.setMaxWaitMillis(20000);
        //使用配置创建连接池
        JedisPool pool = new JedisPool(poolConfig, "localhost");
        //从连接池中获取单个连接
        Jedis jedis = pool.getResource();
        //如果需要密码
        //jedis.auth("password");
        return jedis;
    }
}

运行结果

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
redis 每秒操作：10283次

事实上，Redis的速度比这个操作速度快得多，这里慢是因为我们只是一条条地将命令发送给Redis去执行。如果使用流水线技术它会快得多，将可以达到10万次每秒的操作，十分有利于系统性能的提高。

在Spring中使用Redis

添加依赖以及配置

添加依赖

<!--  SpringBoot集成Redis的起步依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

Spring Data Redis的4种工厂模型

JredisConnectionFactory
JedisConnectionFactory
LettuceConnectionFactory
SrpConnectionFactory

RedisSerializer对象序列化接口

有了RedisConnectionFactory工厂，就可以使用RedisTemplate了。
普通的连接使用没有办法把Java对象直接存入Redis，而需要我们自己提供方案，这时往往需要将对象序列化，然后使用Redis进行存储，
而取回序列化的内容后，在通过转换变为java对象，Spring模板中提供了封装的方案，在它内部提供了RedisSerializer接口和一些实现类。

GenericJackson2JsonRedisSerializer，通用的使用Json2.jar包，将Redis对象的序列化器；
Jackson2JsonRedisSerializer，通过Jackson2.jar包提供的序列化进行转换；
JdkSerializationRedisSerializer，使用JDK的序列化器进行转化；
OxmSerializer，使用Spring O/X对象Object和XML相互转换；
StringRedisSerializer，使用字符串进行序列化；
GenericToStringSerializer，通过通用的字符串序列化进行相互转换；

为此，Spring提供的RedisTemplate还有两个属性：

keySerializer：键序列化器；
valueSerializer：值序列化器；

properties配置方式

# 配置redis
spring.redis.host=127.0.0.1
spring.redis.port=6379

# 数据库池设置
# 最大空闲数
spring.redis.jedis.pool.max-idle=50
# 最大连接数
spring.redis.jedis.pool.max-active=8
# 连接池最大阻塞等待时间
spring.redis.jedis.pool.max-wait=100

xml配置方式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!--最大空闲数-->
        <property name="maxIdle" value="50"/>
        <!--最大连接数-->
        <property name="maxTotal" value="100"/>
        <!--最大等待时间-->
        <property name="maxWaitMillis" value="20000"/>
    </bean>
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="localhost"/>
        <property name="port" value="6379"/>
        <!--<property name="password" value="123456"/>-->
        <property name="poolConfig" ref="poolConfig"/>
    </bean>
    <bean id="jdkSerializationRedisSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
    <bean id="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="keySerializer" ref="stringRedisSerializer"/>
        <property name="valueSerializer" ref="jdkSerializationRedisSerializer"/>
    </bean>

</beans>

配置类注解方式

package com.louris.springboot.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.PoolConfig;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class RedisConfig {
    @Bean(name = "poolConfig")
    public JedisPoolConfig getPoolConfig(){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //最大空闲数
        poolConfig.setMaxIdle(50);
        //最大连接数
        poolConfig.setMaxTotal(100);
        //最大等待时间
        poolConfig.setMaxWaitMillis(20000);
        return poolConfig;
    }
    @Bean(name = "connectionFactory")
    public JedisConnectionFactory getJedisConnectionFactory(){
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setHostName("localhost");
        factory.setPort(6379);
        //factory.setPassword("123456");
        factory.setPoolConfig(getPoolConfig());
        return factory;
    }

    @Bean(name = "jdkSerializationRedisSerializer")
    public JdkSerializationRedisSerializer getJdkRedisSerializer(){
        return new JdkSerializationRedisSerializer();
    }

    @Bean(name = "stringRedisSerializer")
    public StringRedisSerializer getStringRedisSerializer(){
        return new StringRedisSerializer();
    }
    @Bean(name = "redisTemplate")
    public RedisTemplate<String, Object> getRedisTemplate(){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(getJedisConnectionFactory());
        redisTemplate.setKeySerializer(getStringRedisSerializer());
        redisTemplate.setValueSerializer(getJdkRedisSerializer());
        return redisTemplate;
    }

}

对象序列化

package com.louris.springboot.demo.pojo;

import java.io.Serializable;

public class Role implements Serializable {
    private static final long serialVerionsUID = 6977402643848374753L;

    private Long id;
    private String roleName;
    private String note;

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

    public void setNote(String note) {
        this.note = note;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public Long getId() {
        return id;
    }

    public String getNote() {
        return note;
    }

    public String getRoleName() {
        return roleName;
    }
}

测试结果

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
//ApplicationContext applicationContext1 = new ClassPathXmlApplicationContext("spring-redis-config.xml");
Role role = new Role();
role.setId(1L);
role.setRoleName("role_name_1");
role.setNote("note_1");
RedisTemplate<String, Object> redisTemplate = (RedisTemplate<String, Object>) applicationContext.getBean("redisTemplate");
redisTemplate.opsForValue().set("role_1", role);
Role role1 = (Role)redisTemplate.opsForValue().get("role_1");
System.out.println(role1.getRoleName());

09:56:36.673 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Fetching Redis Connection from RedisConnectionFactory
09:56:36.703 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Closing Redis Connection.
09:56:36.704 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Fetching Redis Connection from RedisConnectionFactory
09:56:36.708 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Closing Redis Connection.
role_name_1

同一个Redis连接

注意，以上的使用都是基于RedisTemplate、基于连接池的操作，换句话说，并不能保证每次使用RedisTemplate是操作同一个对Redis的连接。
set和get方法可拿起来很简单，它可能就来自于一个Redis连接池的不同Redis的连接。
为了使得所有的操作都来自于同一个连接，可以使用SessionCallback或者RedisCallback这两个接口，而RedisCallBack是比较底层的封装，其使用不是很友好，所以更多的时候会使用SessionCallback这个接口。

//ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-redis-config.xml");
Role role = new Role();
role.setId(1L);
role.setRoleName("role_name_1");
role.setNote("note_1");
RedisTemplate<String, Object> redisTemplate = (RedisTemplate<String, Object>) applicationContext.getBean("redisTemplate");

SessionCallback<Role> callback = new SessionCallback<Role>() {
    @Override
    public Role execute(RedisOperations operations) throws DataAccessException {
        operations.boundValueOps("role_1").set(role);
        return (Role) operations.boundValueOps("role_1").get();
    }
};
Role savedRole = (Role) redisTemplate.execute(callback);
System.out.println(savedRole.getRoleName());

Redis的6种数据类型

数据类型	数据类型存储的值	说明
STRING(字符串)	可以是保存字符串、整数和浮点数	可以对字符串进行操作，比如增加字符或者求子串；如果是整数或者浮点数，可以实现计算，比如自增等
LIST(列表)	它是一个链表，它的每一个节点都包含一个字符串	Redis支持从链表的两端插入或者弹出节点，或者通过偏移对它进行剪裁；还可以读取一个或者多个节点，根据条件删除或者查找节点等
SET(集合)	它是一个收集器，但是是无序的，在它里面每一个元素都是一个字符串，而且是独一无二，各不相同的	可以新增、读取、删除单个元素；检测一个元素是否在集合中；计算它和其他集合的交集、并集和差集等；随机从集合中读取元素
HASH(哈希散列表)	它类似于Java语言中的Map，是一个键值对应的无序列表	可以增、删、查、改单个键值时，也可以获取所有的键值对
ZSET(有序集合)	它是一个有序的集合，可以包含字符串、整数、浮点数、分值（score），元素的排序是依据分值的大小来决定的	可以增、删、查、改元素，根据分值的范围或者成员来获取对应的元素
HyperLogLog(基数)	它的作用是计算重复的值，以确定存储的数量	只提供基数的运算，不提供返回的功能。

Redis和数据库的异同

NoSQL的数据主要存储在内存中（部分可以持久化到磁盘），而数据库主要是磁盘；
NoSQL数据结构比较简单，虽然能处理很多的问题，但是其功能毕竟是有限的，不如数据库的SQL语句强大，支持更为复杂的计算；
NoSQL并不完全安全稳定，由于它基于内存，一旦停电或者机器故障数据就很容易丢失数据，其持久化能力也是有限的，而基于磁盘的数据库则不会出现这样的问题；
NoSQL的数据完整性、事务能力、安全性、可靠性及可扩展性都不及数据库

Redis数据结构常用命令

Redis数据结构——字符串

常用操作

命令	说明	备注
set key value	设置键值对	最常用的写入命令
get key	通过键获取值	最常用的读取命令
del key	通过key，删除键值对	删除命令，返回删除数，注意，它是一个通用的命令，换句话说在其他数据结构中，也可以使用它
strlen key	求key指向字符串的长度	返回长度
getset key value	修改原来key的对应值，并将旧值返回	如果原来值为空，则返回为空，并设置新值
getrange key start end	获取子串	记字符串的长度为len，把字符串看作一个数组，而Redis是以0开始计数的，所以start和end的取值范围为0到len-1
append key value	将新的字符串value，加入到原来的key指向的字符串末	返回key指向新字符串的长度

本地操作测试

D:\download\Redis-x64-3.2.100>redis-cli.exe -h 127.0.0.1 -p 6379
127.0.0.1:6379> set key1 value1
OK
127.0.0.1:6379> set key2 value2
OK
127.0.0.1:6379> get key1
"value1"
127.0.0.1:6379> del key1
(integer) 1
127.0.0.1:6379> strlen key2
(integer) 6
127.0.0.1:6379> getset key2 new_value2
"value2"
127.0.0.1:6379> get key2
"new_value2"
127.0.0.1:6379> getrange key2 0 3
"new_"
127.0.0.1:6379> append key2 _app
(integer) 14
127.0.0.1:6379> get key2
"new_value2_app"
127.0.0.1:6379>

Spring操作测试

@Bean(name = "redisTemplate")
public RedisTemplate<String, Object> getRedisTemplate(){
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(getJedisConnectionFactory());
    redisTemplate.setKeySerializer(getStringRedisSerializer());
    redisTemplate.setValueSerializer(getStringRedisSerializer());
    return redisTemplate;
}

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
//ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-redis-config.xml");
RedisTemplate<String, String> redisTemplate = (RedisTemplate<String, String>) applicationContext.getBean("redisTemplate");
//设置值
redisTemplate.opsForValue().set("key1", "value1");
redisTemplate.opsForValue().set("key2", "value2");
//通过key获取值
String value1 = redisTemplate.opsForValue().get("key1");
System.out.println(value1);
//通过key删除值
redisTemplate.delete("key1");
//求长度
Long length = redisTemplate.opsForValue().size("key2");
System.out.println(length);
//设置新值并返回旧值
String oldValue2 = redisTemplate.opsForValue().getAndSet("key2", "new_value2");
System.out.println(oldValue2);
//通过key获取值
String value2 = redisTemplate.opsForValue().get("key2");
System.out.println(value2);
//求子串
String rangeValue2 = redisTemplate.opsForValue().get("key2", 0, 3);
System.out.println(rangeValue2);
//追加字符串到末尾，返回新串长度
int newLen = redisTemplate.opsForValue().append("key2", "_app");
System.out.println(newLen);

String appendValue2 = redisTemplate.opsForValue().get("key2");
System.out.println(appendValue2);

value1
6
value2
new_value2
new_
14
new_value2_app

简单运算

如果字符串是数字（整数或者浮点数），那么Redis还能支持简单的运算

命令	说明	备注
incr key	在原字段上加1	只能对整数操作
incrby key increment	在原字段上加上整数（increment）	只能对整数操作
decr key	在原字段上减1	只能对整数操作
decrby key decrement	在原字段上减去整数（decrement）	只能对整数操作
incrbyfloat key increment	在原字段上加上浮点数（increment）	可以操作浮点数或者整数

本地测试

127.0.0.1:6379> set val 8
OK
127.0.0.1:6379> incr val
(integer) 9
127.0.0.1:6379> decr val
(integer) 8
127.0.0.1:6379> decrby val 2
(integer) 6
127.0.0.1:6379> incrby float val 2.3
(error) ERR wrong number of arguments for 'incrby' command
127.0.0.1:6379> incrbyfloat val 2.3
"8.300000000000001"

Spring测试

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
//ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-redis-config.xml");
RedisTemplate<String, String> redisTemplate = (RedisTemplate<String, String>) applicationContext.getBean("redisTemplate");

String value1 = redisTemplate.execute(new SessionCallback<String>() {
    @Override
    public String execute(RedisOperations operations) throws DataAccessException {
        operations.boundValueOps("i").set("9");
        return (String) operations.boundValueOps("i").get();
    }
});
System.out.println(value1);

String value2 = redisTemplate.execute(new SessionCallback<String>() {
    @Override
    public String execute(RedisOperations operations) throws DataAccessException {
        operations.boundValueOps("i").increment(1);
        return (String) operations.boundValueOps("i").get();
    }
});
System.out.println(value2);

String value3 = redisTemplate.execute(new SessionCallback<String>() {
    @Override
    public  String execute(RedisOperations operations) throws DataAccessException {
        operations.boundValueOps("i").decrement();
        return (String) operations.boundValueOps("i").get();
    }
});
System.out.println(value3);

String value4 = redisTemplate.execute(new SessionCallback<String>() {
    @Override
    public  String execute(RedisOperations operations) throws DataAccessException {
        operations.boundValueOps("i").decrement(6);
        return (String) operations.boundValueOps("i").get();
    }
});
System.out.println(value4);

String value5 = redisTemplate.execute(new SessionCallback<String>() {
    @Override
    public  String execute(RedisOperations operations) throws DataAccessException {
        operations.boundValueOps("i").increment(2.3);
        return (String) operations.boundValueOps("i").get();
    }
});
System.out.println(value5);

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
//ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-redis-config.xml");
RedisTemplate<String, String> redisTemplate = (RedisTemplate<String, String>) applicationContext.getBean("redisTemplate");

redisTemplate.opsForValue().set("i", "9");
System.out.println(redisTemplate.opsForValue().get("i"));

System.out.println(redisTemplate.opsForValue().increment("i"));

System.out.println(redisTemplate.opsForValue().decrement("i", 1));

System.out.println(redisTemplate.opsForValue().decrement("i", 6));

System.out.println(redisTemplate.opsForValue().increment("i", 2.3));

Redis数据结构——哈希

命令	说明	备注
hdel key field1 [field2……]	删除hash结构中的某个（些）字段	可以进行多个字段的删除
hexists key field	判断hash结构中是否存在field字段	存在返回1，否则返回0
hgetall key	获取所有hash结构中的键值	返回键和值
hincrby key field increment	指定给hash结构中的某一字段加上一个整数	要求该字段也是整数字符串
hincrbyfloat key field increment	指定给hash结构中的某一字段加上一个浮点数	要求该字段是数字型字符串
hkeys key	返回hash中所有的键
hlen key	返回hash中键值对的数量
hmget key field1 [field2……]	返回hash中指定的键的值，可以是多个	依次返回值
hmget key filed1 value1 [field2 value2]	hash结构设置多个键值对
hset key field value	在hash结构中设置键值对	单个设值
hsetnx key field value	当hash结构中不存在对应的键，才设置值
hvals key	获取hash结构中所有的值

哈希结构的大小，如果哈希结构是个很大的键值对，那么使用它要十分注意，尤其是关于hkeys、hgetall、hvals等返回所有哈希结构数据的命令，会造成大量数据的读取。这需要考虑性能和读取数据大小对JVM内存的影响。
对于数字的操作命令hincrby而言，要求存储的也是整数型的字符串；对于hincrbyfloat而言，则要求使用浮点数或者整数，否则命令会失败。

本地测试

127.0.0.1:6379> hmset role_1 id 001 roleName role_name_001 note note_001
OK
127.0.0.1:6379> hgetall role_1
1) "id"
2) "001"
3) "roleName"
4) "role_name_001"
5) "note"
6) "note_001"
127.0.0.1:6379> hgetall key
(empty list or set)
127.0.0.1:6379> hkeys key
(empty list or set)
127.0.0.1:6379> hkeys role_1
1) "id"
2) "roleName"
3) "note"
127.0.0.1:6379> hmset hash f1 val1 f2 val2
OK
127.0.0.1:6379> hset hash f3 6
(integer) 1
127.0.0.1:6379> hexists hash f2
(integer) 1
127.0.0.1:6379> hgetall hash
1) "f1"
2) "val1"
3) "f2"
4) "val2"
5) "f3"
6) "6"
127.0.0.1:6379> hkeys hash
1) "f1"
2) "f2"
3) "f3"
127.0.0.1:6379> hincrby hash f3 2
(integer) 8
127.0.0.1:6379> hincrbyfloat hash f3 0.88
"8.880000000000001"
127.0.0.1:6379> hlen hash
(integer) 3
127.0.0.1:6379> hmget hash f1 f2
1) "val1"
2) "val2"
127.0.0.1:6379> hsetnx key f4 val4
(integer) 1
127.0.0.1:6379> hvals hash
1) "val1"
2) "val2"
3) "8.880000000000001"
127.0.0.1:6379> hsetnx hash f4 val4
(integer) 1
127.0.0.1:6379> hvals hash
1) "val1"
2) "val2"
3) "8.880000000000001"
4) "val4"
127.0.0.1:6379> hkeys hash
1) "f1"
2) "f2"
3) "f3"
4) "f4"
127.0.0.1:6379> hdel hash f1
(integer) 1
127.0.0.1:6379> hkeys hash
1) "f2"
2) "f3"
3) "f4"
127.0.0.1:6379>

Spring测试

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
//ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-redis-config.xml");
RedisTemplate<String, String> redisTemplate = (RedisTemplate<String, String>) applicationContext.getBean("redisTemplate");

String key = "hash";
Map<String, String> map = new HashMap<>();
map.put("f1", "val1");
map.put("f2", "val2");
//相当于hmset命令
redisTemplate.opsForHash().putAll(key, map);
//相当于hset命令
redisTemplate.opsForHash().put(key, "f3", "6");
printValueForHash(redisTemplate, key, "f3");

//相当于hexists key field命令
boolean exists = redisTemplate.opsForHash().hasKey(key, "f3");
System.out.println(exists);

//相当于hgetall命令
Map keyValMap = redisTemplate.opsForHash().entries(key);
//相当于hincrby命令
redisTemplate.opsForHash().increment(key, "f3", 2);
printValueForHash(redisTemplate, key, "f3");
//相当于hincrbyfloat命令
redisTemplate.opsForHash().increment(key, "f3", 0.88);
printValueForHash(redisTemplate, key, "f3");
//相当于hvals命令
List valueList = redisTemplate.opsForHash().values(key);
//相当于hkeys命令
Set keyList = redisTemplate.opsForHash().keys(key);
List<String> fieldList = new ArrayList<>();
fieldList.add("f1");
fieldList.add("f2");
//相当于hmget命令
List valueList2 = redisTemplate.opsForHash().multiGet(key, keyList);
//相当于hsetnx命令
boolean success = redisTemplate.opsForHash().putIfAbsent(key, "f4", "val4");
System.out.println(success);
//相当于hdel命令
Long result = redisTemplate.opsForHash().delete(key, "f1", "f2");
System.out.println(result);

6
true
8
8.880000000000001
false
2

Redis数据结构——链表（linked-list）

Redis的链表是双向链表，支持左右插入删除等操作。

常规命令

命令	说明	备注
lpush key node1 [node2..]…	把节点node1加入到链表最左边	如果是node1、node2…noden这样加入，那么链表开头从左到右的顺序是noden…node2、node1
rpush key nod1 [node2..]…	把节点node1加入到链表的最右边	如果node1、node2…noden这样加入，那么链表开头从左到右的顺序是node1、node2…noden
lindex key index	读取下标为index的节点	返回节点字符串，从0开始算
llen key	求链表的长度	返回链表节点数
lpop key	删除左边第一个节点，并将其返回
rpop key	删除右边第一个节点，并将其返回
linsert key before\|after pivot node	插入一个节点node，并且可以指定在值为pivot的节点的前面（before）或者后面（after）	如果list不存在，则报错；如果没有值为对应pivot的，也会插入失败返回-1
lpushx list node	如果存在key为list的链表，则插入节点node，并且作为从左到右的第一个节点	如果list不存在，则失败
rpushx list node	如果存在key为list的链表，则插入节点node，并且作为从左到右的最后一个节点	如果list不存在，则失败
lrange list start end	获取链表list从start下标到end下标的节点值	包含start和end下标的值
lrem list count value	如果count为0，则删除所有值等于value的节点；如果count不是0，则先对count取绝对值，假设记为abs，然后从左到右删除不大于abs个等于value的节点	注意，count为整数，如果是负数，则Redis会先求取其绝对值，然后传递到后台操作
lset key index node	设置列表下标为index的节点的值为node
ltrim key start stop	修剪链表，只保留从start到stop的区间的节点，其余的都删除掉	包含start和end的下标的节点会保留

本地测试

D:\download\Redis-x64-3.2.100>redis-cli.exe -h 127.0.0.1 -p 6379
127.0.0.1:6379> lpush list node3 node2 node1
(integer) 3
127.0.0.1:6379> rpush list node4
(integer) 4
127.0.0.1:6379> lindex list 0
"node1"
127.0.0.1:6379> llen list
(integer) 4
127.0.0.1:6379> lpop list
"node1"
127.0.0.1:6379> rpop list
"node4"
127.0.0.1:6379> linsert list before node2 before_node
(integer) 3
127.0.0.1:6379> linsert list after node2 after_node
(integer) 4
127.0.0.1:6379> lpushx list head
(integer) 5
127.0.0.1:6379> rpushx list 0 10
(error) ERR wrong number of arguments for 'rpushx' command
127.0.0.1:6379> rpush list end
(integer) 6
127.0.0.1:6379> lrange list 0 19
1) "head"
2) "before_node"
3) "node2"
4) "after_node"
5) "node3"
6) "end"
127.0.0.1:6379> lpush list node node node
(integer) 9
127.0.0.1:6379> lrem list 3 node
(integer) 3
127.0.0.1:6379> lset list 0 new_head_value
OK
127.0.0.1:6379> lrange list 0 10
1) "new_head_value"
2) "before_node"
3) "node2"
4) "after_node"
5) "node3"
6) "end"
127.0.0.1:6379>

链表的阻塞命令

命令	说明	备注
blpop key timeout	移出并获取列表的第一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止	相对于lpop命令，它的操作是进程安全的
brpop key timeout	移出并获取列表的最后一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止	相对于rpop命令，它的操作是进程安全的
rpoplpush key src dest	按从左到右的顺序，将一个链表的最后一个元素移除，并插入到目标链表最左边	不能设置超时时间
brpoplpush key src dest timeout	按从左到右的顺序，将一个链表的最后一个元素移除，并插入到目标链表最左边，并可以设置超时时间	可设置超时时间

本地测试

127.0.0.1:6379> lpush list1 node1 node2 node3 node4 node5
(integer) 5
127.0.0.1:6379> blpop list1 2
1) "list1"
2) "node5"
127.0.0.1:6379> brpop list1 3
1) "list1"
2) "node1"
127.0.0.1:6379> lpush list2 data1 data2 data3
(integer) 3
127.0.0.1:6379> rpoplpush list1 list2
"node2"
127.0.0.1:6379> brpoplpush list1 list2 3
"node3"
127.0.0.1:6379> lrange list1 0 10
1) "node4"
127.0.0.1:6379> lrange list2 0 10
1) "node3"
2) "node2"
3) "data3"
4) "data2"
5) "data1"
127.0.0.1:6379>

Spring测试

常规操作测试

package com.louris.springboot.demo;

import com.fasterxml.jackson.databind.util.ObjectBuffer;
import com.louris.springboot.demo.config.RedisConfig;
import com.louris.springboot.demo.pojo.Role;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisListCommands;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.*;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {

        SpringApplication.run(DemoApplication.class, args);

        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
        //ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-redis-config.xml");
        RedisTemplate<String, String> redisTemplate = (RedisTemplate<String, String>) applicationContext.getBean("redisTemplate");
        try{
            //删除链表，以便我们可以反复测试
            redisTemplate.delete("list");
            //把node3插入链表list
            redisTemplate.opsForList().leftPush("list", "node3");
            List<String> nodeList = new ArrayList<>();
            for(int i = 2; i >= 1; i --){
                nodeList.add("node" + i);
            }
            //相当于lpush把多个价值从左插入链表
            redisTemplate.opsForList().leftPushAll("list", nodeList);
            //从右边插入一个节点
            redisTemplate.opsForList().rightPush("list", "node4");
            //获取下标为0的节点
            String node1 = (String) redisTemplate.opsForList().index("list", 0);
            //获取链表长度
            long size = redisTemplate.opsForList().size("list");
            //从左边弹出一个节点
            String lpop = (String) redisTemplate.opsForList().leftPop("list");
            //从右边弹出一个节点
            String rpop = (String) redisTemplate.opsForList().rightPop("list");
            //注意，需要使用更为底层的命令才能操作linsert命令
            //使用linsert命令在node2前插入一个节点
            redisTemplate.getConnectionFactory().getConnection().lInsert("list".getBytes(StandardCharsets.UTF_8),
                    RedisListCommands.Position.BEFORE,
                    "node2".getBytes(StandardCharsets.UTF_8),
                    "before_node".getBytes(StandardCharsets.UTF_8));
            //判断list是否存在，如果存在则从左边插入head节点
            redisTemplate.opsForList().leftPushIfPresent("list", "head");
            //判断list是否存在，如果存在则从右边插入end节点
            redisTemplate.opsForList().rightPushIfPresent("list", "end");
            //从左到右，或者下标从0到10的节点元素
            List valueList = redisTemplate.opsForList().range("list", 0, 10);
            nodeList.clear();
            for(int i = 1; i <= 3; i ++){
                nodeList.add("node");
            }
            //在链表左边插入三个值为node的节点
            redisTemplate.opsForList().leftPushAll("list", nodeList);
            //从左到右删除至多三个node节点
            redisTemplate.opsForList().remove("list", 3, "node");
            //给链表下标为0的节点设置新值
            redisTemplate.opsForList().set("list", 0, "new_head_value");
        }catch (Exception e){
            e.printStackTrace();
        }
        printList(redisTemplate, "list");
    }
    private static void printList(RedisTemplate<String, String> redisTemplate, String key){
        //链表长度
        Long size = redisTemplate.opsForList().size(key);
        //获取整个链表的值
        List valueList = redisTemplate.opsForList().range(key, 0, size);
        //打印
        System.out.println(valueList);
    }
    private static void printValueForHash(RedisTemplate<String, String> redisTemplate, String key, String field){
        String value = (String) redisTemplate.opsForHash().get(key, field);
        System.out.println(value);
    }
}

1	[new_head_value, before_node, node2, node3, end]

阻塞操作测试

package com.louris.springboot.demo;

import com.fasterxml.jackson.databind.util.ObjectBuffer;
import com.louris.springboot.demo.config.RedisConfig;
import com.louris.springboot.demo.pojo.Role;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisListCommands;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.TimeUnit;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {

        SpringApplication.run(DemoApplication.class, args);

        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
        //ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-redis-config.xml");
        RedisTemplate<String, String> redisTemplate = (RedisTemplate<String, String>) applicationContext.getBean("redisTemplate");
        //清空数据，可以重复测试
        redisTemplate.delete("list1");
        redisTemplate.delete("list2");
        //初始化链表list1
        List<String> nodeList = new ArrayList<>();
        for(int i = 1; i <= 5; i ++){
            nodeList.add("node" + i);
        }
        redisTemplate.opsForList().leftPushAll("list1", nodeList);
        //Spring使用参数超时作为阻塞命令区分，等价于blpop命令，并且可以设置时间参数
        printList(redisTemplate, "list1");
        redisTemplate.opsForList().leftPop("list1", 1, TimeUnit.SECONDS);
        //Spring使用参数超时时间作为阻塞命令区分，等价于brpop命令，并且可以设置时间参数
        redisTemplate.opsForList().rightPop("list1", 1, TimeUnit.SECONDS);
        nodeList.clear();
        for(int i = 1; i <= 3; i ++){
            nodeList.add("data" + i);
        }
        redisTemplate.opsForList().leftPushAll("list2", nodeList);
        //相当于rpoplpush命令，弹出list1最右边的节点，插入到list2最左边
        redisTemplate.opsForList().rightPopAndLeftPush("list1", "list2");
        printList(redisTemplate, "list1");
        printList(redisTemplate, "list2");
        //相当于brpoplpush命令，注意在Spring中使用超时参数区分
        redisTemplate.opsForList().rightPopAndLeftPush("list1", "list2", 1, TimeUnit.SECONDS);
        //打印链表数据
        printList(redisTemplate, "list1");
        printList(redisTemplate, "list2");
    }
    private static void printList(RedisTemplate<String, String> redisTemplate, String key){
        //链表长度
        Long size = redisTemplate.opsForList().size(key);
        //获取整个链表的值
        List valueList = redisTemplate.opsForList().range(key, 0, size);
        //打印
        System.out.println(valueList);
    }
    private static void printValueForHash(RedisTemplate<String, String> redisTemplate, String key, String field){
        String value = (String) redisTemplate.opsForHash().get(key, field);
        System.out.println(value);
    }
}

[node5, node4, node3, node2, node1]
[node4, node3]
[node2, data3, data2, data1]
[node4]
[node3, node2, data3, data2, data1]

Redis数据结构——集合

理论上一个集合可以存储$2^{31} - 1$个元素，因为采用哈希表结构，所以对于Redis集合的插入、删除和查找的时间复杂度都是$O(1)$

命令	说明	备注
sadd key member1 [member2 member3 ……]	给键为key的集合增加成员	可以同时增加多个
scard key	统计键为key的集合成员数
sdiff key1 [key2]	找出两个集合的差集	参数如果是单key，那么Redis就返回这个key的所有元素
sdiffstore des key1 [key2]	先按sdiff命令的规则，找出key1和key2两个集合的差集，然后将其保存到des集合中
sinter key1 [key2]	求key1和key2两个集合的交集	参数如果是单key，那么Redis就返回这个key的所有元素
sinterstore des key1 key2	先按sinter命令的规则，找出key1和key2两个结合的交集，然后保存到des中
sismember key member	判断member是否键为key的集合的成员	如果是返回0，否则返回0
smember key	返回集合所有成员	如果数据量大，需要考虑迭代遍历的问题
smove src des member	将成员member从集合src迁移到集合des中
spop key	随机弹出集合的一个元素	注意其随机性，因为集合是无序的
srandmember key [key]	随机返回集合中一个或者多个元素，count为限制返回总数，如果count为负数，则先求其绝对值	count为整数，如果不填默认为1，如果count大于等于集合总数，则返回整个集合
srem key member1 [member2……]	移出集合中的元素，可以是多个元素	对于很大的集合可以通过它删除部分元素，避免删除大量数据引发Redis停顿
sunion key1 [key2]	求两个集合的并集	参数如果是单key，那么Redis就返回这个key的所有元素
sunionstore des key1 key2	先执行sunion命令求出并集，然后保存到键为des的集合中

本地测试

D:\download\Redis-x64-3.2.100>redis-cli.exe -h 127.0.0.1 -p 6379
127.0.0.1:6379> sadd set1 v1 v2 v3 v4 v5 v6
(integer) 6
127.0.0.1:6379> sadd set2 v2 v4 v6 v8
(integer) 4
127.0.0.1:6379> sdiffstore diff_set set1 set2
(integer) 3
127.0.0.1:6379> smembers diff_set
1) "v1"
2) "v3"
3) "v5"
127.0.0.1:6379> sunionstore union_set set1 set2
(integer) 7
127.0.0.1:6379> smember union_set
(error) ERR unknown command 'smember'
127.0.0.1:6379> smembers union_set
1) "v1"
2) "v6"
3) "v5"
4) "v2"
5) "v3"
6) "v4"
7) "v8"
127.0.0.1:6379> sinterstore inter_set set1 set2
(integer) 3
127.0.0.1:6379> smembers inter_set
1) "v6"
2) "v4"
3) "v2"
127.0.0.1:6379>

Spring测试

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
//ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-redis-config.xml");
RedisTemplate<String, String> redisTemplate = (RedisTemplate<String, String>) applicationContext.getBean("redisTemplate");
Set set = null;
//将元素加入列表
redisTemplate.boundSetOps("set1").add("v1", "v2", "v3", "v4", "v5", "v6");
redisTemplate.boundSetOps("set2").add("v0", "v2", "v4", "v6", "v8");
//求集合长度
redisTemplate.opsForSet().size("set1");
//求差集
set = redisTemplate.opsForSet().difference("set1", "set2");
//求并集
set = redisTemplate.opsForSet().intersect("set1", "set2");
//判断是否集合中的元素
boolean exists = redisTemplate.opsForSet().isMember("set1", "v1");
//获取集合所有元素
set = redisTemplate.opsForSet().members("set1");
//从集合中随机弹出一个元素
String val = (String) redisTemplate.opsForSet().pop("set1");
//随机获取一个集合的元素
val = (String) redisTemplate.opsForSet().randomMember("set1");
//随机获取2个集合的元素
List list = redisTemplate.opsForSet().randomMembers("set1", 2L);
//删除一个集合的元素，参数可以是多个
redisTemplate.opsForSet().remove("set1", "v1");
//求两个集合的并集
redisTemplate.opsForSet().union("set1", "set2");
//求两个集合的差集，并保存到集合diff_set中
redisTemplate.opsForSet().differenceAndStore("set1", "set2", "diff_set");
//求两个集合的交集，并保存到集合Inter_set中
redisTemplate.opsForSet().intersectAndStore("set1", "set2", "inter_set");
//求两个集合的并集，并保存到集合union_set中
redisTemplate.opsForSet().unionAndStore("set1", "set2", "union_set");

Redis数据结构——有序集合

添加、删除、查找的时间复杂度都是$O(1)$，集合最大成员数为$2^{31} - 1$

有序集合，可以支持对分数排序，底层实现有两种方式：字典和跳表

Redis基础命令

命令	说明	备注
zadd key score1 value1 [score2 value2 ……]	向有序集合的key，增加一个或者多个成员	如果不存在对应的key，则创建键为key的有序集合
zcard key	获取有序集合的成员数
zcount key min max	根据分数返回对应的成员列表	min为最小值，max为最大值，默认为包含min和max值，采用数学区间表示的方法，如果需要不包含，则在分数前面加入”(“，注意支持”[“
zincrby key increment member	给有序集合成员值为member的分数增加increment
zinterstore desKey numkeys key1 [key2 key3 ……]	求多个有序集合的交集，并且将结果保存到desKey中	numKeys是一个整数，表示多个有序结合
zlexcount key min max	求有序集合key成员值在min和max的范围	这里范围为key的成员值，Redis借助数据区间的表示方法，”[“表示包含该值，”(“表示不包含该值
zrange key start stop [winthscores]	按照分值的大小（从小到大）返回成员，加入start和stop参数可以截取某一段返回。如果输入可选项withscores，则连同分数一起返回	这里记集合最大长度为len，则Redis会将集合排序后，形成一个从0到len-1的下标，然后根据start和stop控制的下标（包含start和stop）返回
zrank key member	按从小到大求有序集合的排行
zrangebylex key min max [limit offset count]	根据值的大小，从小到大排序，min为最小值，max为最大值；limit选项可选，当Redis求出范围集合后，会产生下标0到n，然后根据偏移量offset和限定返回数count，返回对应的成员
zrangebyscore key min max[withscores] [limit offset count]	根据分数大小，从小到大求取范围，选项withscores和limit同上
zremrangebyscore key start stop	根据分数区间进行删除
zremrangebyrank key start stop	按照分数排行从小到大的排序删除，从0开始计算
zremrangebylex key min max	按照值的分布进行删除
zrevrange key start stop [withscores]	从大到小的按分数排序，参数同上
zrevrangebyscore key max min [withscore]	从大到小的按分数排序，参数同上
zrevrank key member	按从大到小的顺序，求元素的排行
zscore key member	返回成员的分数值
zunionstore desKey numKeys [key1 key2 key3 key4 ……]	求多个有序集合的并集，其中numKeys是有序集合的个数

本地测试

127.0.0.1:6379> zadd zset1 1 x1 2 x2 3 x3 4 x4 5 x5 6 x6 7 x7 8 x8 9 x9
(integer) 9
127.0.0.1:6379> zadd zset2 1 y1 2 x2 3 y3 4 x4 5 y5 6 x6 7 y7 8 x8 9 y9
(integer) 9
127.0.0.1:6379> zcard zset1
(integer) 9
127.0.0.1:6379> zcount zset1 1 4
(integer) 4
127.0.0.1:6379> zinterstore des_key 2 zset1 zset2
(integer) 4
127.0.0.1:6379> zlexcount zset1 x1 x5
(error) ERR min or max not valid string range item
127.0.0.1:6379> zlexcount zset1
(error) ERR wrong number of arguments for 'zlexcount' command
127.0.0.1:6379> zlexcount zset1 (x1 [x5
(integer) 4
127.0.0.1:6379> zrange zset1 1 5 withscores
 1) "x2"
 2) "2"
 3) "x3"
 4) "3"
 5) "x4"
 6) "4"
 7) "x5"
 8) "5"
 9) "x6"
10) "6"
127.0.0.1:6379> zrange zset1 5 7 withscores
1) "x6"
2) "6"
3) "x7"
4) "7"
5) "x8"
6) "8"
127.0.0.1:6379> zrank zset1 x5
(integer) 4
127.0.0.1:6379> zrangebylex zset1 (x1 [x6
1) "x2"
2) "x3"
3) "x4"
4) "x5"
5) "x6"
127.0.0.1:6379> zrangebyscore zset1 5 7
1) "x5"
2) "x6"
3) "x7"
127.0.0.1:6379> zrangebyscore zset1 2 7 withscores
 1) "x2"
 2) "2"
 3) "x3"
 4) "3"
 5) "x4"
 6) "4"
 7) "x5"
 8) "5"
 9) "x6"
10) "6"
11) "x7"
12) "7"
127.0.0.1:6379> zrevrange zset1 1 5
1) "x8"
2) "x7"
3) "x6"
4) "x5"
5) "x4"
127.0.0.1:6379> zrevrangebyscore zset2 5  2 withscores
1) "y5"
2) "5"
3) "x4"
4) "4"
5) "y3"
6) "3"
7) "x2"
8) "2"
127.0.0.1:6379> zrevrank zset1 x4
(integer) 5
127.0.0.1:6379> zscore zset1 x5
"5"
127.0.0.1:6379> zunionstore des_key 2 zset1 zset2
(integer) 14
127.0.0.1:6379> zincrby zset1 5 x9
"14"
127.0.0.1:6379> zremrangebyscore zset1 3 2
(integer) 0
127.0.0.1:6379> zremrangebyscore zset1 3 5
(integer) 3
127.0.0.1:6379> zremrangebyrank zset1 1 3
(integer) 3
127.0.0.1:6379> zremrangebylex zset2 (y1 (y5
(integer) 2
127.0.0.1:6379>

Spring测试

public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
        RedisTemplate<String, String> redisTemplate = (RedisTemplate<String, String>) applicationContext.getBean("redisTemplate");
        //Spring提供接口TypedTuple操作有序结合
        Set<ZSetOperations.TypedTuple<String>> set1 = new HashSet<>();
        Set<ZSetOperations.TypedTuple<String>> set2 = new HashSet<>();
        int j = 9;
        for(int i = 1; i <= 9; i ++) {
            j--;
            //计算分数和值
            Double score1 = Double.valueOf(i);
            String value1 = "x" + i;
            Double score2 = Double.valueOf(j);
            String value2 = j % 2 == 1 ? "y" + j : "x" + j;
            //使用Spring提供的默认TypedTuple——DefaultTypedTuple
            ZSetOperations.TypedTuple<String> typedTuple1 = new DefaultTypedTuple<>(value1, score1);
            set1.add(typedTuple1);
            ZSetOperations.TypedTuple<String> typedTuple2 = new DefaultTypedTuple<>(value2, score2);
            set2.add(typedTuple2);
        }
        //将元素插入有序集合zset1
        redisTemplate.opsForZSet().add("zset1", set1);
        redisTemplate.opsForZSet().add("zset2", set2);
        //统计总数
        Long size = null;
        size = redisTemplate.opsForZSet().zCard("set1");
        //计分数为score，那么下面的方法就是求3<=score<=6的元素
        size = redisTemplate.opsForZSet().count("zset1", 3, 6);
        Set<String> set = null;
        //从下标一开始截取5个元素，但是不返回分数，每一个元素是String
        set = redisTemplate.opsForZSet().range("zset1", 1, 5);
        printSet(set);
        //截取集合所有元素，并且对集合按分数排序，并返回分数，每一个元素是TypedTuple
        set1 = redisTemplate.opsForZSet().rangeWithScores("zset1", 0, -1);
        printTypedTuple(set1);
        //将zset1和zset2两个集合的交集放入集合inter_zset
        size = redisTemplate.opsForZSet().intersectAndStore("zset1", "zset2", "inter_zset");
        //区间
        RedisZSetCommands.Range range = RedisZSetCommands.Range.range();
        range.lt("x8"); //小于
        range.gt("x1"); //大于
        set = redisTemplate.opsForZSet().rangeByLex("zset1", range);
        printSet(set);
        range.lte("x8"); //小于等于
        range.gte("x1"); //大于等于
        set = redisTemplate.opsForZSet().rangeByLex("zset1", range);
        printSet(set);
        //限制返回个数
        RedisZSetCommands.Limit limit = RedisZSetCommands.Limit.limit();
        //限制返回个数
        limit.count(4);
        //限制从第五个开始截取
        limit.offset(5);
        //求区间内的元素，并限制返回4条
        set = redisTemplate.opsForZSet().rangeByLex("zset1", range, limit);
        printSet(set);
        //求排行，排名第1返回0，第2返回1
        Long rank = redisTemplate.opsForZSet().rank("zset1", "x4");
        System.out.println("rank = " + rank);
        //删除元素，返回删除个数
        size = redisTemplate.opsForZSet().remove("zset1", "x5", "x6");
        System.out.println("delete = " + size);
        //按照排行删除从0开始算起，这里将删除排名第2和第3的元素
        size = redisTemplate.opsForZSet().removeRange("zset2", 1, 2);
        //获取所有集合的元素和分数，以-1代表全部元素
        set1 = redisTemplate.opsForZSet().rangeWithScores("zset2", 0, -1);
        printTypedTuple(set1);
        //删除指定的元素
        size = redisTemplate.opsForZSet().remove("zset2", "y5", "y3");
        System.out.println(size);
        //给集合中的一个元素的分数加上11
        Double dbl = redisTemplate.opsForZSet().incrementScore("zset1", "x1", 11);
        redisTemplate.opsForZSet().removeRangeByScore("zset1", 1, 2);
        set1 = redisTemplate.opsForZSet().reverseRangeWithScores("zset2", 1, 10);
        printTypedTuple(set1);
    }

    private static void printTypedTuple(Set<ZSetOperations.TypedTuple<String>> set){
        if(set != null && set.isEmpty()) return;
        Iterator<ZSetOperations.TypedTuple<String>> iterator = set.iterator();
        while(iterator.hasNext()){
            ZSetOperations.TypedTuple<String> val = (ZSetOperations.TypedTuple<String>) iterator.next();
            System.out.println("{value=" + val.getValue() + ", score=" + val.getScore() + "}\n");
        }
    }
    private static void printSet(Set<String> set){
        if(set != null && set.isEmpty()) return;
        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()){
            String val = iterator.next();
            System.out.println(val + "\t");
        }
        System.out.println();
    }

x2
x3
x4
x5
x6

{value=x1, score=1.0}

{value=x2, score=2.0}

{value=x3, score=3.0}

{value=x4, score=4.0}

{value=x5, score=5.0}

{value=x6, score=6.0}

{value=x7, score=7.0}

{value=x8, score=8.0}

{value=x9, score=9.0}

x2
x3
x4
x5
x6
x7

x1
x2
x3
x4
x5
x6
x7
x8

x6
x7
x8

rank = 3
delete = 2
{value=x0, score=0.0}

{value=y3, score=3.0}

{value=x4, score=4.0}

{value=y5, score=5.0}

{value=x6, score=6.0}

{value=y7, score=7.0}

{value=x8, score=8.0}

2
{value=y7, score=7.0}

{value=x6, score=6.0}

{value=x4, score=4.0}

{value=x0, score=0.0}

基数——HyperLogLog

基数是一种算法。举个例子，一本英文著作由数百万个单词组成，你的内存却不足以存储它们，那么我们先分析一下业务。英文单词本身是有限的，在这本书的几百万个单词中有许许多多重复单词，扣去重复的单词，这本书中也就是几千到一万多个单词而已，那么内存就足够存储它们了。基数的作用是评估大约需要准备多少个存储单元去存储数据，但是基数的算法一般会存在一定的误差（一般是可控的）。

基数并不是存储元素，存储元素消耗内存空间比较大，而是给某一个有重复元素的数据集和（一般是很大的数据集合）评估需要的空间单元数，所以它没有办法进行存储，工作中用得不多。

命令	说明	备注
pfadd key element	添加指定元素到HyperLogLog中	如果已经存储元素，则返回为0，添加失败
pfcount key	返回HyperLogLog的基数值
pfmerge desKey key1 [key2 key3……]	合并多个HyperLogLog，并将其保存在desKey中

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
RedisTemplate<String, String> redisTemplate = (RedisTemplate<String, String>) applicationContext.getBean("redisTemplate");
redisTemplate.opsForHyperLogLog().add("HyperLogLog", "a", "b", "c", "d", "a");
redisTemplate.opsForHyperLogLog().add("HyperLogLog2", "a");
redisTemplate.opsForHyperLogLog().add("HyperLogLog2", "z");
Long size = redisTemplate.opsForHyperLogLog().size("HyperLogLog");
System.out.println(size);
size = redisTemplate.opsForHyperLogLog().size("HyperLogLog2");
System.out.println(size);
redisTemplate.opsForHyperLogLog().union("des_key", "HyperLogLog", "HyperLogLog2");
size = redisTemplate.opsForHyperLogLog().size("des_key");
System.out.println(size);

1
2
3

4
2
5

Redis的一些常用技术

Redis的事务时使用MULTI-EXEC的命令组合，使用它可以提供两个重要的保证：

事务是一个被隔离的操作，事务中的方法都会被Redis进行序列化并按顺序执行，事务在执行的过程中不会被其他客户端发生的命令所打断；
事务是一个原子性的操作，它要么全部执行，要么就什么都不执行

在一个Redis的连接中，请注意要求是一个连接，所以更多的时候在使用Spring中会使用SessionCallback接口进行处理，在Redis中使用事务会经过3个过程：

开启事务
命令进入队列
执行事务

命令	说明	备注
multi	开启事务命令，之后的命令就进入队列，而不会马上被执行	在事务生存期间，所有的Redis关于数据结构的命令都会入队
watch key1 [key2 ……]	监听某些键，当被监听的键在事务执行前被修改，则事务会被回滚	使用乐观锁
unwatch key1 [key2 ……]	取消监听某些键
exec	执行事务，如果被监听的键没有被修改，则采用执行命令，否则就回滚事务	在执行事务队列存储的命令前，Redis会检测被监听的键值对有没有发生变化，如果没有则执行命令，否则就回滚事务
discard	回滚事务	回滚进入队列的事务命令，之后就不能再用exec命令提交了

Redis的基础事务

本地测试

在Redis中开启事务是multi命令，而执行事务时exec命令。multi到exec命令之间的Redis命令将采取进入队列的形式，直至exec命令的出现，才会一次性发送队列里的命令去执行，而在执行这些命令的时候其他客户端就不能再插入任何命令了，这就是Redis的事务机制。

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set key1 value1
QUEUED
127.0.0.1:6379> get key1
QUEUED
127.0.0.1:6379> exec
1) OK
2) "value1"
127.0.0.1:6379>

如果回滚事务，则可以使用discard命令，它就会进入在事务队列中的命令，这样事务中的方法就不会被执行了。

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set key1 value1
QUEUED
127.0.0.1:6379> get key1
QUEUED
127.0.0.1:6379> exec
1) OK
2) "value1"
127.0.0.1:6379> discard
(error) ERR DISCARD without MULTI
127.0.0.1:6379>

Spring测试

1	redisTemplate.setEnableTransactionSupport(true);

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
RedisTemplate redisTemplate = (RedisTemplate) applicationContext.getBean(RedisTemplate.class);
SessionCallback callback = new SessionCallback() {
    @Override
    public String execute(RedisOperations ops) throws DataAccessException {
        ops.multi();
        ops.boundValueOps("key1").set("value1");
        //注意由于命令只是进入队列，而没有被执行，所以此处采用get命令，而value却返回为null
        String value = (String) ops.boundValueOps("key1").get();
        System.out.println("事务执行过程中，命令入队列，而没有被执行，所以value为空：value=" + value);
        //此时list会保存之前进入队列的所有命令的结果
        List<Object> list = ops.exec(); //执行事务
        //事务结束后，获取value1
        value = (String) redisTemplate.opsForValue().get("key1");
        return value;
    }
};
//执行Redis的命令
String value = (String) redisTemplate.execute(callback);
System.out.println(value);

1 2	事务执行过程中，命令入队列，而没有被执行，所以value为空：value=null value1

探索Redis事务回滚

对于Redis而言，不单单需要注意其事务处理的过程，其回滚的能力也和数据库不太一样。
在命令入队的时候，Redis就会检测事务的命令是否正确：

如果不正确则会产生错误。无论之前和之后的命令都会被事务所回滚，就变为什么都没有执行；
如果命令格式正确，而因为操作数据结构引起的错误，则该命令执行出现错误，而其之前和之后的命令都会被正常执行。

对于一些重要的操作，我们需要通过程序去检测数据的正确性，以保证Redis事务的正确执行，避免出现数据不一致的情况。Redis之所以保持这样简易的事务，完全是为了保证移动互联网的核心问题——性能。

命令正确，数据类型错误

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set key1 value1
QUEUED
127.0.0.1:6379> set key2 value2
QUEUED
127.0.0.1:6379> incr key1
QUEUED
127.0.0.1:6379> del key2
QUEUED
127.0.0.1:6379> exec
1) OK
2) OK
3) (error) ERR value is not an integer or out of range
4) (integer) 1
127.0.0.1:6379>

命令错误

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set key1 value1
QUEUED
127.0.0.1:6379> set key2 value2
QUEUED
127.0.0.1:6379> incy key1
(error) ERR unknown command 'incy'
127.0.0.1:6379> del key2
QUEUED
127.0.0.1:6379> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get key1
(nil)
127.0.0.1:6379> get key2
(nil)
127.0.0.1:6379>

使用watch命令监控事务

在Redis中使用watch命令可以决定事务是执行还是回滚。一般而言，可以在multi命令之前使用watch命令监控某些键值对，然后使用multi命令开启事务，执行各类对数据结构进行操作的命令，这个时候这些命令就会进入队列。当Redis使用exec命令执行事务的是偶，它首先会去比对被watch命令所监控的键值对，如果没有发生变化，那么它会执行事务队列中的命令，提交事务；如果发生变化，那么它不会执行任何事务中的命令，而去事务回滚。无论事务是否回滚，Redis都会去取消执行事务前的watch命令。

正常事务提交

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> set key1 value1
OK
127.0.0.1:6379> watch key1
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set key2 value2
QUEUED
127.0.0.1:6379> exec
1) OK
127.0.0.1:6379> get key2
"value2"
127.0.0.1:6379>

事务回滚

客户端1：

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> set key1 value1
OK
127.0.0.1:6379> watch key1
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set key2 value2
QUEUED
127.0.0.1:6379> exec
(nil)
127.0.0.1:6379> get key2
(nil)

客户端2：在客户端1 设置key2键值对时，修改key1：

1
2
3

127.0.0.1:6379> set key1 val1
OK
127.0.0.1:6379>

流水线（pipelined）

在事务中Redis提供了队列，这是一个可以批量执行任务的队列，这样性能就比较高，但是使用multi…exec事务命令是有系统开销的，因为它会检测对应的锁和序列化命令。有时候我们希望在没有任何附加条件的场景下去使用队列批量执行一系列的命令，从而提高系统性能，这就是Redis的流水线技术。

Java API测试

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Pipeline;

import java.util.List;

public class RedisTest {

    public static void main(String[] args){
        Jedis jedis = connectionPool();
        long start = System.currentTimeMillis();
        //开启流水线
        Pipeline pipeline = jedis.pipelined();
        //这里测试10万条的读/写操作
        for(int i = 1; i <= 100000; i ++){
            int j = i + 1;
            pipeline.set("pipeline_key_" + j, "pipeline_value_" + j);
            pipeline.get("pipeline_key_" + j);
        }
        //pipeline.sync(); //这里只执行同步，但是不返回结果
        //pipeline.syncAndReturnAll(); 将返回执行过的命令返回的List列表结果
        List result = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        //计算耗时
        System.out.println("耗时：" + (end - start) + "毫秒");
    }
    private static Jedis connectionPool(){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //最大空闲数
        poolConfig.setMaxIdle(50);
        //最大连接数
        poolConfig.setMaxTotal(100);
        //最大等待毫秒数
        poolConfig.setMaxWaitMillis(20000);
        //使用配置创建连接池
        JedisPool pool = new JedisPool(poolConfig, "localhost");
        //从连接池中获取单个连接

        Jedis jedis = pool.getResource();
        //如果需要密码
        //jedis.auth("password");
        return jedis;
    }
}

耗时：742毫秒

Spring测试

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
RedisTemplate redisTemplate = (RedisTemplate) applicationContext.getBean(RedisTemplate.class);
SessionCallback callback = new SessionCallback() {
    @Override
    public Object execute(RedisOperations redisOperations) throws DataAccessException {
        for(int i = 0; i < 100000; i ++){
            int j = i + 1;
            redisOperations.boundValueOps("pipeline_key_" + j).set("pipeline_value_" + j);
            redisOperations.boundValueOps("pipeline_key_" + j).get();
        }
        return null;
    }
};
long start = System.currentTimeMillis();
//执行Redis的流水线命令
List resultList = redisTemplate.executePipelined(callback);
long end = System.currentTimeMillis();
System.out.println(end - start);

发布订阅

当使用银行卡消费的时候，银行往往会通过微信、短信或邮件通知用户这笔交易的信息，这便是一种发布订阅模式，这里的发布是交易信息的发布，订阅则是各个渠道。这在实际工作中十分常用，Redis支持这样的一个模式。

要有发送的消息渠道，让记账系统能够发送消息；
要有订阅者（短信、邮件、微信等系统）订阅这个渠道的消息

本地测试

可以看到客户端2在publish消息后，客户端1收到了消息。

客户端1：订阅了一个名为chat的渠道

C:\Program Files\Redis>redis-cli.exe -h 127.0.0.1 -p 6379
127.0.0.1:6379> SUBSCRIBE chat
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "chat"
3) (integer) 1
1) "message"
2) "chat"
3) "let's go!!"

客户端2：向渠道chat发送消息

C:\Program Files\Redis>redis-cli.exe -h 127.0.0.1 -p 6379
127.0.0.1:6379> publish chat "let's go!!"
(integer) 1
127.0.0.1:6379>

Spring测试

Redis发布订阅监听类

package com.louris.springboot.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class RedisMessageListener implements MessageListener {
    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public void onMessage(Message message, byte[] bytes) {
        //获取消息
        byte[] body = message.getBody();
        //使用值序列化器转换
        String msgBody = (String) redisTemplate.getValueSerializer().deserialize(body);
        System.out.println(msgBody);
        //获取channel
        byte[] channel = message.getChannel();
        //使用字符串序列化器转换
        String channelStr = (String) redisTemplate.getStringSerializer().deserialize(channel);
        System.out.println(channelStr);
        //渠道名称转换
        String bytesStr = new String(bytes);
        System.out.println(bytesStr);
    }

    public void setRedisTemplate(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public RedisTemplate getRedisTemplate() {
        return redisTemplate;
    }
}

RedisConfig配置类

package com.louris.springboot.IoCImpl.config;

import com.louris.springboot.utils.RedisMessageListener;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.listener.ChannelTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.Topic;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import redis.clients.jedis.JedisPoolConfig;

import javax.sql.DataSource;
import javax.xml.crypto.Data;
import java.util.*;

@Configuration
@ComponentScan(basePackages = "com.louris.springboot.utils")
public class RedisConfig {

    @Bean(name = "poolConfig")
    public JedisPoolConfig getPoolConfig(){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //最大空闲数
        poolConfig.setMaxIdle(50);
        //最大连接数
        poolConfig.setMaxTotal(100);
        //最大等待时间
        poolConfig.setMaxWaitMillis(20000);
        return poolConfig;
    }
    @Bean(name = "connectionFactory")
    public JedisConnectionFactory getJedisConnectionFactory(){
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setHostName("localhost");
        factory.setPort(6379);
        //factory.setPassword("123456");
        factory.setPoolConfig(getPoolConfig());
        return factory;
    }

    @Bean(name = "jdkSerializationRedisSerializer")
    public JdkSerializationRedisSerializer getJdkRedisSerializer(){
        return new JdkSerializationRedisSerializer();
    }

    @Bean(name = "stringRedisSerializer")
    public StringRedisSerializer getStringRedisSerializer(){
        return new StringRedisSerializer();
    }

    @Bean(name = "redisTemplate")
    public RedisTemplate<String, String> getRedisTemplate(){
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(getJedisConnectionFactory());
        redisTemplate.setKeySerializer(getStringRedisSerializer());
        redisTemplate.setValueSerializer(getStringRedisSerializer());
        redisTemplate.setEnableTransactionSupport(true);
        return redisTemplate;
    }

    @Bean(name = "taskExecutor")
    public ThreadPoolTaskExecutor getExecutor(){
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(20);
        return taskExecutor;
    }

    @Autowired
    private RedisMessageListener listener = null;

    @Bean(name = "topicContainer")
    public RedisMessageListenerContainer getContainer(){
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(getJedisConnectionFactory());
        container.setTaskExecutor(getExecutor());
        ChannelTopic channelTopic = new ChannelTopic("chat");
        container.addMessageListener(listener, channelTopic);
        return container;
    }
}

启动类

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
RedisTemplate redisTemplate = (RedisTemplate) applicationContext.getBean(RedisTemplate.class);
String channel = "chat";
redisTemplate.convertAndSend(channel, "I am lazy!!");

测试结果

1
2
3

I am lazy!!
chat
chat

超时命令

命令	说明	备注
persist key	持久化key，取消超时时间	移除key的超时时间
ttl key	查看key的超时时间	以秒计算，-1代表没有超时时间，如果不存在key或者key已经超时则为-2
expire key seconds	设置超时时间戳	以秒为单位
expireat key timestamp	设置超时时间点	用uninx时间戳确定
pptl key milliseconds	查看key的超时时间戳	用毫秒计算
pexpire key	设置键值超时的时间	以毫秒为单位
Pexpireat key stamptimes	设置超时时间点	以毫秒为单位的uninx时间戳

本地测试

127.0.0.1:6379> set key1 value1
OK
127.0.0.1:6379> get key1
"value1"
127.0.0.1:6379> ttl key1
(integer) -1
127.0.0.1:6379> expire key1 120
(integer) 1
127.0.0.1:6379> ttl key1
(integer) 114
127.0.0.1:6379> persist key1
(integer) 1
127.0.0.1:6379> ttl key1
(integer) -1
127.0.0.1:6379> expireat key1 1478278200
(integer) 1
127.0.0.1:6379> ttl key1
(integer) -2

Spring测试

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
RedisTemplate redisTemplate = (RedisTemplate) applicationContext.getBean(RedisTemplate.class);
SessionCallback sessionCallback = new SessionCallback() {
    @Override
    public Object execute(RedisOperations redisOperations) throws DataAccessException {
        redisOperations.boundValueOps("key1").set("value1");
        String keyValue = (String) redisOperations.boundValueOps("key1").get();
        Long expSecond = redisOperations.getExpire("key1");
        System.out.println(expSecond);
        boolean b = false;
        b = redisOperations.expire("key1", 120L, TimeUnit.SECONDS);
        b = redisOperations.persist("key1");
        Long l = 0L;
        l = redisOperations.getExpire("key1");
        Long now = System.currentTimeMillis();
        Date date = new Date();
        date.setTime(now + 120000);
        redisOperations.expireAt("key", date);
        return null;
    }
};
redisTemplate.execute(sessionCallback);

如果key超时了，Redis会回收key的存储空间吗？
答案是不会。

Redis的key超时不会被其自动回收，它只会标识哪些键值对超时了。这样做的一个好处在于，如果一个很大的键值对超时，比如一个列表或者哈希结构，存在数以百万个元素，要对其回收需要很长的事件。如果采用超时回收，则可能产生停顿。坏处也很明显，这些超时的键值对会浪费比较多的空间。

Redis提供两种方式回收这些超时键值对：

定时回收：指在确定的某个事件触发一段代码，回收超时的键值对
惰性回收则是当一个超时的键，被再次用get命令访问时，将触发Redis将其从内存中清空

使用Lua语言

在Redis的2.6以上版本中，除了可以使用命令外，还可以使用Lua语言操作Redis，从前面的命令可以Redis命令的计算鞥哪里并不算很强大，而使用Lua语言则在很大程度上弥补了Redis的这个不足。只是在Redis中，执行Lua语言是原子性的，这个特性有助于Redis对并发数据一致性的支持。

执行输入Lua程序代码

一般命令格式

命令格式：
eval lua-script key-num [key1 key2 key3 ...] [value1 value2 value3 ...]
其中：

eval代表执行Lua语言的命令
Lua-script代表Lua语言脚本
key-num整数代表参数中有多少个key，需要注意的是Redis中key是从1开始的，如果没有key的参数，那么写0
[key1 key2 key3 ...]是key作为参数传递给Lua语言，也可以不填它是key的参数，但是需要和key-num的个数对应起来。
[value1 value2 value3 ...]这些参数传递给Lua语言，它们是可填可不填的。

C:\Program Files\Redis>redis-cli.exe -h 127.0.0.1 -p 6379
127.0.0.1:6379> eval "return 'hello java'" 0
"hello java"
127.0.0.1:6379> eval "redis.call('set', keys[1], argv[1])" 1 lua-key lua-value
(error) ERR Error running script (call to f_5da76ed59a058931c0fc4d6a1aaa4d59bac041ec): @enable_strict_lua:15: user_script:1: Script attempted to access unexisting global variable 'keys'
127.0.0.1:6379> eval "redis.call('set', KEYS[1], ARGV[1])" 1 lua-key lua-value
(nil)
127.0.0.1:6379> get lua-key
"lua-value"
127.0.0.1:6379>

设置一个键值对，可以在Lua语言中采用redis.call(command, key[param1, param2...])进行操作，其中：

command是命令，包括set、get、del等
Key是被操作的键
param1,param2…代表给key的参数。

KEYS[1]代表读取传递给Lua脚本的第一个key参数，而ARGV[1]代表第一个非key参数。

多次执行同一脚本

有时可能需要多次执行同样一段样本，这个时候可以使用Redis缓存脚本的功能，在Redis中脚本会通过SHA-1签名算法加密脚本，然后返回一个标识字符串，可以通过这个字符串执行加密后的脚本。这样的一个好处在于，如果脚本很长，从客户端传输可能需要很长的时间，那么使用标识字符串，则只需要传递32位字符串即可，这样就能够提高传输的效率，从而提高性能。

首先使用命令：
script load script
这个脚本的返回值是一个SHA-1签名过后的标识字符串记为shastring，通过它可以使用命令执行签名后的脚本：
evalsha shastring keynum [key1 key2 key3 ...] [param1 param2 param3 ...]

127.0.0.1:6379> script load "redis.call('set', KEYS[1], ARGV[1])"
"27d4ba7a9326bdcdabb271c0771037674735bec2"
127.0.0.1:6379> evalsha 27d4ba7a9326bdcdabb271c0771037674735bec2 1 sha-key val
(nil)
127.0.0.1:6379> get sha-key
"val"
127.0.0.1:6379>

Spring测试

ApplicationContext applicationContext = SpringApplication.run(Application.class, args);
RedisTemplate redisTemplate = (RedisTemplate) applicationContext.getBean("redisTemplate");
//如果是简单的操作，使用原来的Jedis会简单些
Jedis jedis = (Jedis) redisTemplate.getConnectionFactory().getConnection().getNativeConnection();
//执行简单的脚本
String helloJava = (String) jedis.eval("return 'hello java'");
System.out.println(helloJava);
//执行带参数的脚本
jedis.eval("redis.call('set', KEYS[1], ARGV[1])", 1, "lua-key", "lua-value");
String luaKey = (String) jedis.get("lua-key");
System.out.println(luaKey);
//缓存脚本，返回sha1签名标识
String sha1 = jedis.scriptLoad("redis.call('set', KEYS[1], ARGV[1])");
//通过标识执行脚本
jedis.evalsha(sha1, 1, new String[]{"sha-key", "sha-val"});
//获取执行脚本后的数据
String shaVal = jedis.get("sha-key");
System.out.println(shaVal);
//关闭连接
jedis.close();

1
2
3

hello java
lua-value
sha-val

ApplicationContext applicationContext = SpringApplication.run(Application.class, args);
RedisTemplate redisTemplate = (RedisTemplate) applicationContext.getBean("redisTemplate");


//定义脚本封装类
DefaultRedisScript<Role> redisScript = new DefaultRedisScript<>();
//设置脚本
redisScript.setScriptText("redis.call('set', KEYS[1], ARGV[1]) return redis.call('get', KEYS[1])");
//定义操作的key列表
List<String> keyList = new ArrayList<>();
keyList.add("role1");
//需要序列化保存和读取的对象
Role role = new Role();
role.setId(1L);
role.setRoleName("role_name_1");
role.setNote("note_1");
//获得标识字符串
String sha1 = redisScript.getSha1();
System.out.println(sha1);
//设置返回结果类型，如果没有这句话，结果返回为空
redisScript.setResultType(Role.class);
//定义序列化器
JdkSerializationRedisSerializer serializationRedisSerializer = new JdkSerializationRedisSerializer();
//执行脚本
//第一个是RedisSript接口对象，第二个是参数序列化器
//第三个是结果序列化器，第四个是Redis的key列表，最后是参数列表
Role obj = (Role) redisTemplate.execute(redisScript, serializationRedisSerializer, serializationRedisSerializer, keyList, role);
//打印结果
System.out.println(obj);

1 2	aac72bd8699ae9c333eff85158365d7bc61a7177 Role{id=1, roleName='role_name_1', note='note_1'}

执行Lua文件

本地测试

redis.call('set', KEYS[1], ARGV[1])
redis.call('set', KEYS[2], ARGV[2])
local n1 = tonumber(redis.call('get', KEYS[1]))
local n2 = tonumber(redis.call('get', KEYS[2]))
if n1 > n2 then
    return 1
end
if n1 == n2 then
    return 0
end
if n1 < n2 then
    return 2
end

需要特别注意，键和参数之间需要用逗号隔开，逗号前后必须都有空格！！

C:\Program Files\Redis>redis-cli --eval test.lua key1 key2, 2 4
(error) ERR Error running script (call to f_4828d75e6222e1b400c218baa4e772ed333f3ea5): @user_script:5: user_script:5: attempt to compare two nil values

C:\Program Files\Redis>redis-cli --eval test.lua key1 key2, 2 4
(error) ERR Error running script (call to f_979e3d9cc79a6ab54e4f3d653e6cda618bc77b03): @user_script:5: user_script:5: attempt to compare two nil values

C:\Program Files\Redis>redis-cli --eval test.lua key1 key2 2 4
(error) ERR Error running script (call to f_979e3d9cc79a6ab54e4f3d653e6cda618bc77b03): @user_script:5: user_script:5: attempt to compare two nil values

C:\Program Files\Redis>redis-cli --eval test.lua key1 key2 , 2 4
(integer) 2

Spring测试

public static void main(String[] args) {
    ApplicationContext applicationContext = SpringApplication.run(Application.class, args);
    RedisTemplate redisTemplate = (RedisTemplate) applicationContext.getBean("redisTemplate");

    //读入文件流
    File file = new File("C:\\Program Files\\Redis\\test.lua");
    byte[] bytes = getFileToByte(file);
    Jedis jedis = (Jedis) redisTemplate.getConnectionFactory().getConnection().getNativeConnection();
    //发送文件二进制给Redis，这样Redis就会返回sha1标识
    byte[] sha1 = jedis.scriptLoad(bytes);
    //使用返回的标识执行，其中第二个参数2，表示使用2个键
    //而后面的字符串都转化为了二进制字节进行传输
    Object obj = jedis.evalsha(sha1, 2, "key1".getBytes(), "key2".getBytes(), "2".getBytes(), "4".getBytes());
    System.out.println(obj);
}

private static byte[] getFileToByte(File file){
    byte[] by = new byte[(int)file.length()];
    try{
        InputStream is = new FileInputStream(file);
        ByteArrayOutputStream bytestream = new ByteArrayOutputStream();
        byte[] bb = new byte[2048];
        int ch;
        ch = is.read(bb);
        while(ch != -1){
            bytestream.write(bb, 0, ch);
            ch = is.read(bb);
        }
        by = bytestream.toByteArray();
    }catch (Exception e){
        e.printStackTrace();
    }
    return by;
}

Redis配置

Redis基础配置文件

Windows系统，默认的配置文件就是redis.window.conf;
Linux系统，则是redis.conf

Redis备份（持久化）

Redis中存在两种方式的备份：

快照（snapshotting），它是备份当前瞬间Redis在内存中的数据记录；
只追加文件（Append-Only File， AOF），其作用就是当Redis执行写命令后，在一定的条件下降执行过的写命令依次保存在Redis的文件中，将来就可以依次执行那些保存的命令恢复Redis的数据了。

（1）对于快照备份而言，如果当前Reids的数据量大，备份可能造成Redis卡顿，但是恢复重启比较快速。
（2）对于AOF备份而言，它只是追加写入命令，所以备份一般不会造成Redis卡顿，但是恢复重启要执行更多的命令，备份文件可能也很大，使用者使用的时候需要注意。

Redis中允许使用其中的一种、同时使用两种，或者两种都不用。

快照模式的配置项

1
2
3

save 900 1
save 300 10
save 60 10000

配置项的含义：

当900秒执行1个写命令时，启用快照备份；
当300秒执行10个写命令时，启用快照备份；
当60秒内执行10000个写命令时，启用快照备份

Redis执行save命令的时候，将禁止写入命令

1	stop-writes-on-bgsave-error yes

bgsave命令，它是一个异步保存命令，也就是系统将启动另外一条进程，把Redis的数据保存到对应的数据文件中。它和save命令最大的不同是它不会阻塞客户端的写入，也就是在执行bgsave的时候，允许客户端继续读/写Redis。
在默认情况下，如果Redis执行bgsave失败后，Redis将停止接受写操作，这样以一种强硬的方式让用户知道数据不能正确的持久化到磁盘，否则就会没人注意到灾难的发生；
如果后台保存进程重新启动工作了，Redis也将自动允许写操作。
然而如果安装了靠谱的监控，可能不希望Redis这样做，可以将其修改为no

1	rdbchecksum yes

这个命令的意思是是否对rdb文件进行检验

rdb文件实际是Redis持久化的数据文件，当采用快照模式备份时，Redis将使用它保存数据，将来可以使用它恢复数据

1	dbfilename dump.rdb

只追加文件模式的配置项

1	appendonly no

如果appendonly配置为no，则不启用AOF方式进行备份。如果appendonly配置为yes，则以AOF方式备份Redis数据，那么此时Redis会按照配置，在特定的时候执行追加命令，用以备份数据。

1	appendfilename "appendonly.aof"

这里定义追加的写入文件为appendonly.aof，采用AOF追加文件备份的时候命令都会写到这里。

1
2
3

# appendfsync always
appendfsync everysec
# appendfsync no

AOF文件和Redis命令是同步频率的，假设配置为always，其含义为当Redis执行命令的时候，则同时同步到AOF文件，这样会使得Redis同步刷新AOF文件，造成缓慢。
而采用everysec则代表每秒同步一次命令到AOF文件。
采用no的时候，则由客户端调用命令执行备份，Redis本身不备份文件。
对于always配置的时候，每次命令都会持久化，它的好处在于安全，坏处在于每次都持久化性能较差。
采用everysec的安全性不如always，别分可能会丢失一秒以内的命令，但是银行也不大，安全度上课，性能可以得到保障。
采用no，则性能有所保障，但是由于失去备份，所以安全性比较差。
建议采用默认配置everysec

1	no-appendfsync-on-rewrite no

它指定是否在后台AOF文件rewrite（重写）期间调用fsync，默认为no，表示要调用fsync（无论后台是否有子进程在刷盘）。Redis在后台写RDB文件或重写AOF文件期间会存在大量磁盘I/O，此时，在某些Linux系统中，调用fsync可能会阻塞。

1	auto-aof-rewrite-percentage 100

它指定Redis重写AOF文件的条件，默认为100，表示与上次rewrite的AOF文件大小相比，当前AOF文件增长量超过上次AOF文件大小的100%时，就会触发background rewrite。若配置为0，则会禁用自动rewrite。

1	auto-aof-rewrite-min-size 64mb

它指定触发rewrite的AOF文件大小。若AOF文件小于该值，即使当前文件的增量比例达到auto-aof-rewrite-percentage的配置值，也不会触发自动rewrite。即这两个配置项同时满足时，才会触发rewrite。

1	aof-load-truncated yes

Redis在恢复时会忽略最后一条可能存在问题的指令，默认为yes。即在AOF写入时，可能存在指令写错的问题（突然断电、写了一半），这种情况下yes会log并继续，而no会直接恢复失败。

Redis内存回收策略

Redis也会因为内存不足而产生错误，也可能因为回收过久而导致系统长期的停顿，因此掌握执行回收策略十分有必要。在Redis的配置文件中，当Redis的内存达到规定的最大值时，允许配置6种策略中的一种进行淘汰键值，并且将一些键值对进行回收。

# volatile-lru -> Evict using approximated LRU. only keys with an expire set.
# allkeys-lru -> Evict any key using approximated LRU.
# volatile-lfu -> Evict using approximated LFU, only keys with an expire set.
# allkeys-lfu -> Evict any key using approximated LFU.
# volatile-random -> Remove a random key having an expire set.
# allkeys-random -> Remove a random key, any key.
# volatile-ttl -> Remove the key with the nearest expire time (minor TTL)
# noeviction -> Don't evict anything, just return an error on write operations.

volatile-lru：采用最近使用最少的淘汰策略，Redis将回收那些超时的（仅仅是超时的）键值对，也就是它只淘汰那些超时的键值对；
allkeys-lru：采用淘汰最少使用的策略，Redis将对所有的（不仅仅是超时的）键值对采用最近使用最少的淘汰策略；
volatile-random：采用随机淘汰策略删除超时的（仅仅是超时的）键值对；
allkeys-random：采用随机淘汰策略删除所有的（不仅仅是超时的）键值对，这个策略不常用；
volatile-ttl：采用删除存货时间最短的键值对策略；
noeviction：根本就不淘汰任何键值对，当内存已满时，如果做读操作，例如get命令，它将正常工作，而做些操作，它将返回错误。也就是说，当Redis采用这个策略内存达到最大的时候，它就只能读不能写了。

Redis在默认情况下会曹勇noeviction策略。换句话说，如果内存已满，则不再提供写入操作，而只提供读取操作。显然这往往并不能满足我们的要求，因为对于互联网系统而言，常常会涉及数以百万甚至更多的用户，所以往往需要设置回收策略。

注意：LRU算法或者TTL算法都不是很精确算法，而是一个近似算法。Redis不会通过对全部的键值对进行比较来确定最精确的时间值，从而确定删除哪个键值对，因为这将消耗太多的时间，导致回收垃圾执行的时间太长，造成服务停顿。而在Redis的默认配置文件中，存在着参数maxmemory-samples，它的默认值为3，假设采取了volatile-ttl算法：

假设当前有5个即将超时的键值对：

键值对	剩余超时秒数	备注
A1	6	属于探测样本
A2	3	属于探测样本中最短值，因此最先删除
A3	4	属于探测样本
A4	1	最短值，但是它不属于探测样本，所以没有最先删除
A5	9	但不属于样本

由于配置maxmemory-samples的值为3，如果Redis是按表中的顺序探测，那么它只会取到样本A1、A2、A3，然后进行比较，因为A2国企剩余秒数最少，所以决定淘汰A2，因此A2是最先被删除的。注意，此时即将过期且剩余超时秒数最短的A4却还在内存中，因为它不属于探测样本。这就是Redis中采用的近似算法。当设置maxmemory-samples越大，则Redis删除的就越精确，但是与此同时带来不利的是，Redis也就需要花更多的事件去计算和匹配更为精确的值。

回收超时策略的缺点是必须指明超时的键值对，这会给程序开发带来一些设置超时的代码，无疑增加了开发者的工作量。对所有的键值对进行回收，有可能把正在使用的键值对删掉，增加了存储的不稳定性。对于垃圾回收的策略，还需要注意的是回收的时间，因为在Redis对垃圾的回收期间，会造成系统缓慢。因此，控制其回收时间有一定好处，只是这个时间不能过短或过长。过短则会造成回收次数过于频繁，过长则导致系统单次垃圾回收停顿时间过长，都不利于系统的稳定性，这些都需要设计者在实际的工作中进行思考。

复制

尽管Redis的性能很好，但是有时候依旧满足不了应用的需要，比如过多的用户进入主页，导致Redis被频繁访问，此时就存在大量的读操作。对于一些热门网站的某个时刻（比如促销商品的时候）每秒成千上万的请求是司空见惯的，这个时候大量的读操作就会到达Redis服务器，触发许许多多的操作，显然单靠一台Redis服务器是完全不够用的。一些服务网站对安全性有较高的要求，当主服务器不能正常工作的时候，也需要从服务器代替原来的主服务器，作为灾备，以保证系统可以继续正常的工作。因此更多的时候我们更希望可以读/写分离，读/写分离的前提是读操作远远比写操作频繁得多，如果把数据都存放在多台服务器上那么就可以从多台服务器中读取数据，从而消除了单台服务器的压力，读/写分离的技术已经广泛用于数据库中了。

主从同步基本概念

主从架构设计的思路大概是：

在多台数据服务器中，只有一台主服务器，而主服务器只负责写入数据，不负责让外部程序读取数据；
存在多台从服务器，从服务器不写入数据，只负责同步主服务器的数据，并让外部程序读取数据；
主服务器在写入数据后，即刻将写入数据的命令发送给从服务器，从而使得主从数据同步；
应用程序可以随机读取某一台从服务器的数据，这样就分摊了读数据的压力；
当从服务器不能工作的时候，整个系统将不受影响；当主服务器不能工作的时候，可以方便地从服务器中选举一台来当主服务器。

Redis主从同步配置

对Redis进行主从同步的配置分为主机与从机，主机是一台，而从机可以是多台。
（1）首先，明确主机。当确定哪台机子是主机的时候，关键的两个配置时dir和dbfilename选项，当然必须保证这两个文件时可写的。对于Redis的默认配置而言，dir的默认值为./，而对于dbfilename的默认值为dump.rbd。换句话说，默认采用Redis当前的目录的dump.rdb文件进行同步。
（2）其次，在明确了从机之后，进行进一步配置所要关注的只有replicaof这个配置选项，它的配置格式为：

1	replicaof <masterip> <masterport>

其中，masterip代表主机，port代表端口。
当从机Redis服务重启时，就会同步对应主机的数据了。当不想让从机继续复制主机的数据时，可以在从机的Redis命令客户端发送slaveof no one命令，这样从机就不会再接收主服务器的数据更新了。又或者原来主服务器已经无法工作了，而你可能需要去复制新的主机，这个时候执行slaveof server port就能让从机复制另外一台主机的数据了。
（3）在实际的Linux环境中，配置文件redis.conf中还有一个bind的配置，默认为127.0.0.1，也就是只允许本机访问，把它修改为bind 0.0.0.0，其他的服务器就能够访问了。bing是绑定本机的IP地址，port绑定端口，允许其他人访问该IP的端口进行redis连接。

Redis主从同步的过程

略，详见书。

哨兵（Sentinel）模式

主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，既费时费力，还回造成一段时间内服务不可用，这不是一种推荐的方式。
更多时候，优先考虑哨兵模式，它是当前企业应用的主流方式。

哨兵模式概述

Redis可以存在多台服务器，并且实现了主从复制的功能。哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。

哨兵的两个作用：

通过发送命令，让Redis服务器返回检测其运行状态，包括主服务器核从服务器；
当哨兵检测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知到其他的从服务器，修改配置文件，让它们切换主机；

现实中只是一个哨兵进程对Redis服务器进行监控，也可能出现问题，为了处理这个问题，还可以使用多个哨兵的监控，而各个哨兵之间还会相互监控，这样就变为了多个哨兵模式。多个哨兵不仅监控各个Redis服务器，而且哨兵之间相互监控，看看哨兵们是否还“活”着。

故障切换（failover）的过程：假设主服务器宕机，哨兵1先检测到这个结果，当时系统并不会马上进行failover操作，而仅仅是哨兵1主观地认为主机已经不可用，这个现象被称为主观下线。当后面的哨兵也监测到了主服务器不可用，并且有了一定数量的哨兵认为主服务器不可用，那么哨兵之间就会形成一次投票，投票的结果由一个哨兵发起，进行failover操作，在failover操作的过程中切换成功后，就会通过发布订阅方式，让各个哨兵把自己监控的服务器实现切换主机，这个过程被称为客观下线。这样对于客户端而言，一切都是透明的。

搭建哨兵模式

略，以后用到了再来搞。

Spring缓存机制和Redis的结合

Redis和数据库的结合

Redis和数据库读操作

数据缓存往往会在Redis上设置超时时间，当设置Redis的数据超时后，Redis就没法读出数据了，这个时候就会触发程序读取数据库，然后将读取的数据库数据写入Redis（此时会给Redis重设超时时间），这样程序在读取的过程中就能按一定的时间间隔刷新数据了。

伪代码：

public DataObject readMethod(args){
  //尝试从Redis中读取数据
  DataObject dataObject = getRedis(key);
  if(data != null){ //读取数据返回为空，失败
    //从数据库中读取数据
    data = getFromDataBase();
    //重新写入Redis，以便以后读出
    writeRedis(key, data);
    //设置Redis的超时时间为5分钟
    setRedisExpire(key, 5);
  }
}

Redis和数据库写操作

写操作要考虑数据一致的问题，尤其是那些重要的业务数据。
写入业务数据，先从数据库中读取最新数据，然后进行业务操作，更新业务数据到数据库后，再将数据刷新到Redis缓存中，这样就完成了一次写操作。这样的操作就能避免将脏数据写入数据库汇总，这类问题在操作时要注意。

伪代码

public DataObject writeMethod(args){
  //从数据库里读取最新数据
  DataObject dataObject = getFromDataBase(args);
  //执行业务逻辑
  ExecLogic(dataObject);
  //更新数据库数据
  updateDataBase(dataObject);
  //刷新Redis缓存
  updateRedisData(dataObject);
}

使用Spring缓存机制整合Redis

准备测试环境

配置MySQL和Redis以及Spring Cache配置

配置文件配置方式（推荐）

server.port=8081
# 设置连接数据库的信息
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123456

spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource
spring.datasource.dbcp2.max-idle=10
spring.datasource.dbcp2.max-total=50
spring.datasource.dbcp2.max-wait-millis=10000

# 指定MyBatis映射文件的路径
mybatis.mapper-locations=classpath:mapper/*.xml

## 配置logback配置文件的属性
logback.path=D:/
logback.serviceName=myService

# 配置视图解析器
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp


# 配置上传文件
# 是否开启文件上传支持
spring.servlet.multipart.enabled=true
# 文件写入磁盘阈值
spring.servlet.multipart.file-size-threshold=0
# 文件上传临时保存位置
spring.servlet.multipart.location=D:\\JavaTest\\upload
# 单个文件上传的最大大小
spring.servlet.multipart.max-file-size=5MB
# 多个文件上传的最大大小
spring.servlet.multipart.max-request-size=10MB
# 文件是否延迟解析
spring.servlet.multipart.resolve-lazily=false

# 配置redis
spring.redis.host=127.0.0.1
spring.redis.port=6379

# 数据库池设置
# 最大空闲数
spring.redis.jedis.pool.max-idle=50
# 最大连接数
spring.redis.jedis.pool.max-active=8
# 连接池最大阻塞等待时间
spring.redis.jedis.pool.max-wait=100

# 配置Spring缓存
# 如果由底层的缓存管理器支持创建，以逗号分隔的列表缓存名称
spring.cache.cache-names=redisCache
## caffeine缓存配置细节
#spring.cache.caffeine.spec=
## couchbase缓存超时时间，默认是永不超时
#spring.cache.couchbase.expiration=0ms
## 配置encache缓存初始化文件路径
#spring.cache.ehcache.config=
## infinispan缓存配置文件
#spring.cache.infinispan.config=
## jcache缓存配置文件
#spring.cache.jcache.config=
## jcache缓存提供者配置
#spring.cache.jcache.provider=

# 配置Redis缓存管理器
# 是否允许Redis缓存空值
spring.cache.redis.cache-null-values=true
# Redis的键前缀
spring.cache.redis.key-prefix=
# 缓存超时时间戳，配置为0则不设置超时时间
spring.cache.redis.time-to-live=60000ms
# 是否启用Redis的键前缀
spring.cache.redis.use-key-prefix=false
# 缓存类型，在默认的情况下，Spring会自动根据上下文探测
spring.cache.type=redis

配置类自定义配置缓存管理器配置方式

有时候，在自定义时可能存在比较多的设置，也可以不采用Spring Boot自动配置的缓存管理器，而是使用自定义的缓存管理器，这也是没有问题的。

package com.louris.springboot.IoCImpl.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.louris.springboot.utils.RedisMessageListener;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.listener.ChannelTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.Topic;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import redis.clients.jedis.JedisPoolConfig;

import javax.sql.DataSource;
import javax.xml.crypto.Data;
import java.time.Duration;
import java.util.*;

@Configuration
@EnableCaching
@ComponentScan(basePackages = "com.louris.springboot.utils")
public class RedisConfig {

    @Bean(name = "poolConfig")
    public JedisPoolConfig getPoolConfig(){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //最大空闲数
        poolConfig.setMaxIdle(50);
        //最大连接数
        poolConfig.setMaxTotal(100);
        //最大等待时间
        poolConfig.setMaxWaitMillis(20000);
        return poolConfig;
    }
    @Bean(name = "connectionFactory")
    public JedisConnectionFactory getJedisConnectionFactory(){
        JedisConnectionFactory factory = new JedisConnectionFactory(getPoolConfig());
        factory.setHostName("localhost");
        factory.setPort(6379);
        //factory.setPassword("123456");
        factory.afterPropertiesSet(); //调用后初始化方法，没有它将抛出异常
        //factory.setPoolConfig(getPoolConfig());
        return factory;
    }

    @Bean(name = "jdkSerializationRedisSerializer")
    public JdkSerializationRedisSerializer getJdkRedisSerializer(){
        return new JdkSerializationRedisSerializer();
    }

    @Bean(name = "stringRedisSerializer")
    public StringRedisSerializer getStringRedisSerializer(){
        return new StringRedisSerializer();
    }

    @Bean(name = "redisTemplate")
    public RedisTemplate<String, String> getRedisTemplate(){
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        //设置连接工程
        redisTemplate.setConnectionFactory(getJedisConnectionFactory());
        //设置序列化器
        redisTemplate.setDefaultSerializer(getStringRedisSerializer());
        redisTemplate.setKeySerializer(getStringRedisSerializer());
        redisTemplate.setValueSerializer(getJdkRedisSerializer());
        redisTemplate.setHashKeySerializer(getStringRedisSerializer());
        redisTemplate.setHashValueSerializer(getJdkRedisSerializer());
        redisTemplate.setEnableTransactionSupport(true);
        return redisTemplate;
    }

    @Bean(name = "redisCacheManager")
    public CacheManager initRedisCacheManager(@Autowired RedisTemplate redisTemplate){
        RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(getJedisConnectionFactory());
        //启动Redis缓存的默认设置
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        //设置JDK序列化器
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(getJdkRedisSerializer()));
        //禁用前缀
        config = config.disableKeyPrefix();
        //设置1min超时
        config = config.entryTtl(Duration.ofSeconds(60));
        //创建Redis缓存管理器
        return new RedisCacheManager(writer, config);
    }

    @Bean(name = "taskExecutor")
    public ThreadPoolTaskExecutor getExecutor(){
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(20);
        return taskExecutor;
    }

    @Autowired
    private RedisMessageListener listener = null;

    @Bean(name = "topicContainer")
    public RedisMessageListenerContainer getContainer(){
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(getJedisConnectionFactory());
        container.setTaskExecutor(getExecutor());
        ChannelTopic channelTopic = new ChannelTopic("chat");
        container.addMessageListener(listener, channelTopic);
        return container;
    }
}

POJO

package com.louris.springboot.IoCImpl.beans.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import java.io.Serializable;

@Component(value = "role")
//@Scope(value = "prototype")
public class Role implements Serializable {
    private static final long serialVerionsUID = 6977402643848374753L;
    //@Value("#{1}")
    private Long id;
    //@Value("#{'role_name_1'}")
    private String roleName;
    //@Value("#{'role_note_1'}")
    private String note;
    public Role(){}
    public Role(Long id, String roleName, String note){
        this.id = id;
        this.roleName = roleName;
        this.note = note;
    }

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

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public void setNote(String note) {
        this.note = note;
    }

    public String getRoleName() {
        return roleName;
    }

    public String getNote() {
        return note;
    }

    public Long getId() {
        return id;
    }

    @Override
    public String toString() {
        return "Role{" +
                "id=" + id +
                ", roleName='" + roleName + '\'' +
                ", note='" + note + '\'' +
                '}';
    }
}

RoleMapper.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.louris.springboot.IoCImpl.mapper.RoleDao">
    <select id="getRole" resultType="com.louris.springboot.IoCImpl.beans.pojo.Role">
        select id, role_name as roleName, note from t_role where id = #{id}
    </select>

    <delete id="deleteRole">
        delete from t_role where id = #{id}
    </delete>

    <insert id="insertRole" parameterType="com.louris.springboot.IoCImpl.beans.pojo.Role"
            useGeneratedKeys="true" keyProperty="id">
        insert into t_role(role_name, note) values(#{roleName}, #{note})
    </insert>

    <update id="updateRole" parameterType="com.louris.springboot.IoCImpl.beans.pojo.Role">
        update t_role set role_name = #{roleName}, note = #{note} where id = #{id}
    </update>

    <select id="findRoles" resultType="com.louris.springboot.IoCImpl.beans.pojo.Role">
        select id, role_name as roleName, note from t_role
        <where>
            <if test="roleName != null">
                role_name like concat('%', #{roleName}, '%')
            </if>
            <if test="note != null">
                note like concat('%', #{note}, '%')
            </if>
        </where>
    </select>
</mapper>

RoleData持久层接口

package com.louris.springboot.IoCImpl.mapper;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface RoleDao {
    Role getRole(Long id);
    int deleteRole(Long id);
    int insertRole(Role role);
    int updateRole(Role role);
    List<Role> findRoles(@Param("roleName") String roleName, @Param("note") String note);
}

RoleService服务接口

package com.louris.springboot.IoCImpl.mapper;

import com.louris.springboot.IoCImpl.beans.pojo.Role;

import java.util.List;

public interface RoleService {
    Role getRole(Long id);
    int deleteRole(Long id);
    Role insertRole(Role role);
    int updateRole(Role role);
    List<Role> findRoles(String roleName, String note);
}

缓存注解简介

注解	描述
@Cacheable	表明在进入方法之前，Spring会先去缓存服务器中查找对应key的缓存值，如果找到缓存值，那么Spring将不会再调用方法，而是将缓存值读出，返回给调用者；如果找到缓存值，那么Spring就会执行你的方法，将最后的结果通过key保存到缓存服务器中
@CachePut	Spring会将该方法返回的值缓存到缓存服务器中，这里需要注意的是，Spring不会事先去缓存服务器中查找，而是直接执行方法，然后缓存。换句话说，该方法始终会被Spring所调用
@CacheEvict	移除缓存对应的key的值
@Caching	这是一个分组注解，它能够同时应用于其他缓存的注解

注解@Cacheable和@CachePut都可以保存缓存键值对，只是它们的方式略有不同，请注意二者的区别，它们只能运用于有返回值的方法中，而删除缓存key的@CacheEvict则可以用在void的方法上，因为它并不需要去保存任何值
上述注解都能标注到类或者方法之上，如果放到类上，则对所有的方法都有效；如果放到方法上，则只是对方法有效。
在大部分情况下，会放置到方法上。因为@Cacheable和@CachePut可以配置的属性接近，所以把它们归为一类去介绍，而@Caching因为不常用，就不介绍了。
一般而言，对于查询，我们会考虑使用@Cacheable；对于插入和修改，我们会考虑使用@CachePut；对于删除操作，我们会考虑使用@CacheEvict；

注解@Cacheable和@CachePut

属性	配置类型	描述
value	String[]	使用缓存的名称
condition	String	Spring表达式，如果表达式返回值为false，则不会将缓存应用到方法上，true则会
key	String	Spring表达式，可以通过它来计算对应缓存的key
unless	String	Spring表达式，如果表达式返回值为true，则不会将方法的结果方挂到缓存上

Spring表达式值的引用

表达式	描述	备注
#root.args	定义传递给缓存方法的参数	不常用，不予讨论
#root.caches	该方法执行是对应的缓存名称，它是一个数组	同上
#root.target	执行缓存的目标对象	同上
#root.targetClass	目标对象的类，它是#root.target.class的缩写	同上
#root.method	缓存方法	同上
#root.methodName	缓存方法的名称，它是#root.method.name的缩写	同上
#result	方法返回结果值，还可以使用Spring表达式进一步读取其属性	请注意该表达式不能用于注解@Cacheable，因为该注解的方法可能不会被执行，这样返回值就无从谈起了。
#Argument	任意方法的参数，可以通过方法本身的名称或者下标去定义	比如getRole(Long id)方法，想读取id这个参数，可以写为#id，或者#a0，#p0，笔者建议写为#id，这样可读性高

RoleServiceImpl实现类

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.Role;
import com.louris.springboot.IoCImpl.mapper.RoleDao;
import com.louris.springboot.IoCImpl.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Component
public class RoleServiceImpl implements RoleService {

    @Autowired
    private RoleDao roleDao = null;

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    @Cacheable(value = "redisCache", key = "'redis_role_' + #id")
    public Role getRole(Long id) {
        return roleDao.getRole(id);
    }

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    @CachePut(value="redisCache", key="'redis_role_' + #result.id")
    public Role insertRole(Role role) {
        roleDao.insertRole(role);
        return role;
    }

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    @CachePut(value = "redisCache", key = "'redis_role_' + #role.id")
    public int updateRole(Role role) {
        return roleDao.updateRole(role);
    }

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public int deleteRole(Long id) {
        return roleDao.deleteRole(id);
    }

    @Override
    public List<Role> findRoles(String roleName, String note) {
        return roleDao.findRoles(roleName, note);
    }
}

启动测试类

//SpringBoot项目启动入口类
@SpringBootApplication  //SpringBoot核心注解，主要用于开启spring自动配置
@EnableTransactionManagement
public class Application {

    public static void main(String[] args) {
        ApplicationContext applicationContext = SpringApplication.run(Application.class, args);
        //ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RedisConfig.class);
        //获取角色服务类
        RoleService roleService = applicationContext.getBean(RoleService.class);
        Role role = new Role();
        role.setRoleName("role_name_1");
        role.setNote("role_note_1");
        //插入角色
        roleService.insertRole(role); //会回填id
        //获取角色
        Role role1 = roleService.getRole(role.getId());
        role1.setNote("role_note_1_update");
        //更新角色
        roleService.updateRole(role1);
    }
}

测试结果

配置文件配置方式测试结果

2021-10-14 19:25:55.819 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession
2021-10-14 19:25:55.821 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5fc1e4fb]
2021-10-14 19:25:55.825 [main] DEBUG o.m.spring.transaction.SpringManagedTransaction - JDBC Connection [794778569, URL=jdbc:mysql:/ /localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8, MySQL Connector/J] will be managed by Spring
2021-10-14 19:25:55.827 [main] DEBUG c.l.springboot.IoCImpl.mapper.RoleDao.insertRole - ==>  Preparing: insert into t_role(role_name, note) values(?, ?)  
2021-10-14 19:25:55.841 [main] DEBUG c.l.springboot.IoCImpl.mapper.RoleDao.insertRole - ==> Parameters: role_name_1(String), role_note_1(String)
2021-10-14 19:25:55.843 [main] DEBUG c.l.springboot.IoCImpl.mapper.RoleDao.insertRole - <==    Updates: 1
2021-10-14 19:25:55.849 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5fc1e4fb]
2021-10-14 19:25:55.999 [main] DEBUG io.lettuce.core.RedisClient - Trying to get a Redis connection for: redis://127.0.0.1
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.numHeapArenas: 24
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.numDirectArenas: 24
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.pageSize: 8192
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.maxOrder: 11
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.chunkSize: 16777216
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.smallCacheSize: 256
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.normalCacheSize: 64
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.maxCachedBufferCapacity: 32768
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.cacheTrimInterval: 8192
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.cacheTrimIntervalMillis: 0
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.useCacheForAllThreads: true
2021-10-14 19:25:56.298 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.maxCachedByteBuffersPerChunk: 1023
2021-10-14 19:25:56.313 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.allocator.type: pooled
2021-10-14 19:25:56.313 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.threadLocalDirectBufferSize: 0
2021-10-14 19:25:56.313 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.maxThreadLocalCharBufferSize: 16384
2021-10-14 19:25:56.316 [main] DEBUG io.lettuce.core.resource.KqueueProvider - Starting without optional kqueue library
2021-10-14 19:25:56.316 [main] DEBUG io.lettuce.core.resource.EpollProvider - Starting without optional epoll library
2021-10-14 19:25:56.317 [main] DEBUG i.l.core.resource.DefaultEventLoopGroupProvider - Allocating executor io.netty.channel.nio.NioEventLoopGroup
2021-10-14 19:25:56.317 [main] DEBUG i.l.core.resource.DefaultEventLoopGroupProvider - Creating executor io.netty.channel.nio.NioEventLoopGroup
2021-10-14 19:25:56.317 [main] DEBUG io.netty.channel.MultithreadEventLoopGroup - -Dio.netty.eventLoopThreads: 24
2021-10-14 19:25:56.330 [main] DEBUG io.netty.channel.nio.NioEventLoop - -Dio.netty.noKeySetOptimization: false
2021-10-14 19:25:56.330 [main] DEBUG io.netty.channel.nio.NioEventLoop - -Dio.netty.selectorAutoRebuildThreshold: 512
2021-10-14 19:25:56.337 [main] DEBUG i.l.core.resource.DefaultEventLoopGroupProvider - Adding reference to io.netty.channel.nio.NioEventLoopGroup@5cfa2ac5, existing ref count 0
2021-10-14 19:25:56.377 [main] DEBUG io.lettuce.core.RedisClient - Resolved SocketAddress 127.0.0.1/<unresolved>:6379 using redis://127.0.0.1
2021-10-14 19:25:56.385 [main] DEBUG io.lettuce.core.AbstractRedisClient - Connecting to Redis at 127.0.0.1/<unresolved>:6379
2021-10-14 19:25:56.399 [main] DEBUG io.netty.channel.DefaultChannelId - -Dio.netty.processId: 11780 (auto-detected)
2021-10-14 19:25:56.411 [main] DEBUG io.netty.util.NetUtil - -Djava.net.preferIPv4Stack: false
2021-10-14 19:25:56.411 [main] DEBUG io.netty.util.NetUtil - -Djava.net.preferIPv6Addresses: false
2021-10-14 19:25:56.417 [main] DEBUG io.netty.util.NetUtilInitializations - Loopback interface: lo (Software Loopback Interface 1, 127.0.0.1)
2021-10-14 19:25:56.418 [main] DEBUG io.netty.util.NetUtil - Failed to get SOMAXCONN from sysctl and file \proc\sys\net\core\somaxconn. Default: 200
2021-10-14 19:25:56.424 [main] DEBUG io.netty.channel.DefaultChannelId - -Dio.netty.machineId: 8c:ec:4b:ff:fe:cd:47:39 (auto-detected)
2021-10-14 19:25:56.553 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, [id: 0x84f515a0] (inactive), chid=0x1] channelRegistered()
2021-10-14 19:25:56.556 [lettuce-nioEventLoop-4-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.maxCapacityPerThread: 4096
2021-10-14 19:25:56.556 [lettuce-nioEventLoop-4-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.maxSharedCapacityFactor: 2
2021-10-14 19:25:56.556 [lettuce-nioEventLoop-4-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.linkCapacity: 16
2021-10-14 19:25:56.556 [lettuce-nioEventLoop-4-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.ratio: 8
2021-10-14 19:25:56.556 [lettuce-nioEventLoop-4-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.delayedQueue.ratio: 8
2021-10-14 19:25:56.579 [lettuce-nioEventLoop-4-1] DEBUG io.netty.buffer.AbstractByteBuf - -Dio.netty.buffer.checkAccessible: true
2021-10-14 19:25:56.579 [lettuce-nioEventLoop-4-1] DEBUG io.netty.buffer.AbstractByteBuf - -Dio.netty.buffer.checkBounds: true
2021-10-14 19:25:56.579 [lettuce-nioEventLoop-4-1] DEBUG io.netty.util.ResourceLeakDetectorFactory - Loaded default ResourceLeakDetector: io.netty.util.ResourceLeakDetector@51049dd1
2021-10-14 19:25:56.616 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] write(ctx, AsyncCommand [type=HELLO, output=GenericMapOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command], promise)
2021-10-14 19:25:56.618 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandEncoder - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379] writing command AsyncCommand [type=HELLO, output=GenericMapOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.622 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Received: 30 bytes, 1 commands in the stack
2021-10-14 19:25:56.622 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Stack contains: 1 commands
2021-10-14 19:25:56.623 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.RedisStateMachine - Decode done, empty stack: true
2021-10-14 19:25:56.623 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Completing command AsyncCommand [type=HELLO, output=GenericMapOutput [output=null, error='ERR unknown command 'HELLO''], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.624 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] write(ctx, AsyncCommand [type=PING, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command], promise)
2021-10-14 19:25:56.624 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandEncoder - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379] writing command AsyncCommand [type=PING, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.625 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Received: 7 bytes, 1 commands in the stack
2021-10-14 19:25:56.625 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Stack contains: 1 commands
2021-10-14 19:25:56.625 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.RedisStateMachine - Decode done, empty stack: true
2021-10-14 19:25:56.625 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Completing command AsyncCommand [type=PING, output=StatusOutput [output=PONG, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.625 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] channelActive()
2021-10-14 19:25:56.626 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, epid=0x1] activateEndpointAndExecuteBufferedCommands 0 command(s) buffered
2021-10-14 19:25:56.626 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, epid=0x1] activating endpoint
2021-10-14 19:25:56.626 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, epid=0x1] flushCommands()
2021-10-14 19:25:56.626 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, epid=0x1] flushCommands() Flushing 0 commands
2021-10-14 19:25:56.626 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.ConnectionWatchdog - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, last known addr=/127.0.0.1:6379] channelActive()
2021-10-14 19:25:56.626 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] channelActive() done
2021-10-14 19:25:56.626 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.AbstractRedisClient - Connecting to Redis at 127.0.0.1/<unresolved>:6379: Success
2021-10-14 19:25:56.628 [main] DEBUG io.lettuce.core.RedisChannelHandler - dispatching command AsyncCommand [type=SET, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.629 [main] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, epid=0x1] write() writeAndFlush command AsyncCommand [type=SET, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.630 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] write(ctx, AsyncCommand [type=SET, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command], promise)
2021-10-14 19:25:56.630 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandEncoder - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379] writing command AsyncCommand [type=SET, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.631 [main] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, epid=0x1] write() done
2021-10-14 19:25:56.645 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Received: 5 bytes, 1 commands in the stack
2021-10-14 19:25:56.645 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Stack contains: 1 commands
2021-10-14 19:25:56.645 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.RedisStateMachine - Decode done, empty stack: true
2021-10-14 19:25:56.645 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Completing command AsyncCommand [type=SET, output=StatusOutput [output=OK, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.645 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5fc1e4fb]
2021-10-14 19:25:56.645 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5fc1e4fb]
2021-10-14 19:25:56.645 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5fc1e4fb]
2021-10-14 19:25:56.679 [main] DEBUG io.lettuce.core.RedisChannelHandler - dispatching command AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.679 [main] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, epid=0x1] write() writeAndFlush command AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.679 [main] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, epid=0x1] write() done
2021-10-14 19:25:56.679 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] write(ctx, AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command], promise)
2021-10-14 19:25:56.680 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandEncoder - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379] writing command AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.680 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Received: 248 bytes, 1 commands in the stack
2021-10-14 19:25:56.680 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Stack contains: 1 commands
2021-10-14 19:25:56.680 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.RedisStateMachine - Decode done, empty stack: true
2021-10-14 19:25:56.680 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Completing command AsyncCommand [type=GET, output=ValueOutput [output=[B@75657082, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.683 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession
2021-10-14 19:25:56.684 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@a240452]
2021-10-14 19:25:56.684 [main] DEBUG o.m.spring.transaction.SpringManagedTransaction - JDBC Connection [441236678, URL=jdbc:mysql:/ /localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8, MySQL Connector/J] will be managed by Spring
2021-10-14 19:25:56.684 [main] DEBUG c.l.springboot.IoCImpl.mapper.RoleDao.updateRole - ==>  Preparing: update t_role set role_name = ?, note = ? where id = ?  
2021-10-14 19:25:56.684 [main] DEBUG c.l.springboot.IoCImpl.mapper.RoleDao.updateRole - ==> Parameters: role_name_1(String), role_note_1_update(String), 43(Long)
2021-10-14 19:25:56.685 [main] DEBUG c.l.springboot.IoCImpl.mapper.RoleDao.updateRole - <==    Updates: 1
2021-10-14 19:25:56.685 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@a240452]
2021-10-14 19:25:56.686 [main] DEBUG io.lettuce.core.RedisChannelHandler - dispatching command AsyncCommand [type=SET, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.686 [main] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, epid=0x1] write() writeAndFlush command AsyncCommand [type=SET, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.686 [main] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, epid=0x1] write() done
2021-10-14 19:25:56.686 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] write(ctx, AsyncCommand [type=SET, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command], promise)
2021-10-14 19:25:56.687 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandEncoder - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379] writing command AsyncCommand [type=SET, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.687 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Received: 5 bytes, 1 commands in the stack
2021-10-14 19:25:56.687 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Stack contains: 1 commands
2021-10-14 19:25:56.687 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.RedisStateMachine - Decode done, empty stack: true
2021-10-14 19:25:56.687 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xade3db03, /127.0.0.1:52675 -> /127.0.0.1:6379, chid=0x1] Completing command AsyncCommand [type=SET, output=StatusOutput [output=OK, error='null'], commandType=io.lettuce.core.protocol.Command]
2021-10-14 19:25:56.687 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@a240452]
2021-10-14 19:25:56.687 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@a240452]
2021-10-14 19:25:56.687 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@a240452]

因为我们设置了60秒超时时间，所以到期后，查不到数据了。

127.0.0.1:6379> keys *
1) "redis_role_49"
2) "zset1"
3) "\xac\xed\x00\x05t\x00\x05count"
4) "inter_zset"
5) "zset2"
6) "name"
7) "h3"
8) "h1"
9) "h2"
127.0.0.1:6379> get redis_role_49
"\xac\xed\x00\x05sr\x00\x11java.lang.Integer\x12\xe2\xa0\xa4\xf7\x81\x878\x02\x00\x01I\x00\x05valuexr\x00\x10java.lang.Number\x86\xac\x95\x1d\x0b\x94\xe0\x8b\x02\x00\x00xp\x00\x00\x00\x01"
127.0.0.1:6379> get redis_role_49
"\xac\xed\x00\x05sr\x00\x11java.lang.Integer\x12\xe2\xa0\xa4\xf7\x81\x878\x02\x00\x01I\x00\x05valuexr\x00\x10java.lang.Number\x86\xac\x95\x1d\x0b\x94\xe0\x8b\x02\x00\x00xp\x00\x00\x00\x01"
127.0.0.1:6379> get redis_role_49
"\xac\xed\x00\x05sr\x00\x11java.lang.Integer\x12\xe2\xa0\xa4\xf7\x81\x878\x02\x00\x01I\x00\x05valuexr\x00\x10java.lang.Number\x86\xac\x95\x1d\x0b\x94\xe0\x8b\x02\x00\x00xp\x00\x00\x00\x01"
127.0.0.1:6379> get redis_role_49
(nil)
127.0.0.1:6379>

注解@CacheEvict

属性	类型	描述
value	String[]	要使用缓存的名称
key	String	指定Spring表达式返回缓存的key
condition	String	指定Spring表达式，如果返回为true，则执行移除缓存，否则不执行
allEntries	boolean	如果为true，则删除特定缓存所有键值对，默认值为false，请注意它将清除所有缓存服务器的缓存，这个属性慎用
beforeInvocation	boolean	指定在方法前后移除缓存，如果指定为true，则在方法前删除缓存；如果为false，则在方法调用后删除缓存，默认值为false

@Override
@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
@CacheEvict(value = "redisCache", key = "'redis_role_' + #id")
public int deleteRole(Long id) {
    return roleDao.deleteRole(id);
}

不适用缓存的方法

该方法不适用任何缓存注解标注在这个方法上。
注意：使用缓存的前提——高命中率，由于这里根据角色名称和备注查找角色信息，该方法的返回值会根据查询条件而多样化，导致其不确定和命中率地下，对于这样的场景，使用缓存并不能有效提高性能，所以这样的场景，就不再使用缓存了。

@Override
@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
public List<Role> findRoles(String roleName, String note) {
    return roleDao.findRoles(roleName, note);
}

自调用失效问题

@Override
@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
public int insertRoles(List<Role> roleList) {
    for(Role role:roleList){
        //同一类方法调用自己的方法，产生自调用失效问题
        this.insertRole(role);
    }
}

因为缓存注解也是基于Spring AOP实现的，对于Spring AOP的基础是动态代理技术，也就是只有代理对象的相互调用，AOP才有拦截的功能，才能执行缓存注解提供的功能。而这里的自调用是没有代理对象存在的，所以其注解功能也就失效了。

RedisTemplate的实例

在很多时候，我们也许需要使用一些更为高级的缓存服务器的API，如Redis的流水线、事务等，所以也许会使用到RedisTemplate本身。

package com.louris.springboot.IoCImpl.service;

public interface RedisTemplateService {
    void execMultiCommand();
    void execTransaction();
    void execPipeline();
}

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.service.RedisTemplateService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class RedisServiceImpl implements RedisTemplateService {

    @Autowired
    private RedisTemplate redisTemplate = null;

    @Override
    public void execMultiCommand() {
        Object obj = redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations ops) throws DataAccessException {
                ops.boundValueOps("key1").set("abc");
                ops.boundHashOps("hash").put("hash-key-1", "hash-value-1");
                return ops.boundValueOps("key1").get();
            }
        });
        System.out.println(obj);
    }

    @Override
    public void execTransaction() {
        List list = (List) redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations ops) throws DataAccessException {
                //监控
                ops.watch("key1");
                //开启事务
                ops.multi();
                //注意，命令都不会被马上执行，只会收到Redis的队列中，只会返回null
                ops.boundValueOps("key1").set("abc");
                ops.boundHashOps("hash").put("hash-key-1", "hash-value-1");
                ops.opsForValue().get("key1");
                //执行exec方法后会触发事务执行，返回结果，存放到list中
                List result = ops.exec();
                return result;
            }
        });
        System.out.println(list);
    }

    @Override
    public void execPipeline() {
        List list = redisTemplate.executePipelined(new SessionCallback() {
            @Override
            public Object execute(RedisOperations ops) throws DataAccessException {
                //在流水线下，命令不会马上返回结果，结果是一次性执行后返回的
                ops.opsForValue().set("key1", "value1");
                ops.opsForHash().put("hash", "key-hash-1", "value-hash-1");
                ops.opsForValue().get("key1");
                return null;
            }
        });
        System.out.println(list);
    }
}

高并发业务

互联系统应用架构基础分析

防火墙
负载均衡
NoSQL服务器集群
Web服务器集群
数据库集群

负载均衡器的功能：

对业务请求做初步的分析，决定分不分发请求到 Web 服务器，这就好比以个把控的关卡，常见的分发软件比如 Nginx和Apache 等反向代理服务器，它们在关卡处可以通过配置禁止一些无效的请求，比如封禁经常作弊的IP地址，也可以使用 Lua语言联合 NoSQL 缓存技术进行业务分析，这样就可以初步分析业务，决定是否需要分发到服务器；
提供路由算法，它可以提供一些负载均衡的算法，根据各个服务器的负载能力进行合理分发，每一个Web服务器得到比较均衡的请求，从而降低单个服务器的压力，提高系统的响应能力；
限流，对于一些高并发时刻，需要通过限流来处理，因为可能某个时刻通过上述的算法让有效请求过多到达服务器，使得一些Web服务器或者数据库服务器产生宕机。当某台机器宕机后，会使得其他服务器承受更大的请求量，这样就容易产生多台服务器连续宕机的可能性，持续下去就会引发服务器雪崩。因此在这种情况下，负载均衡器有限流的算法，对于请求过多的时刻，可以告知用户系统繁忙，稍后再试，从而保证系统持续可用。

高并发系统的分析和设计

有效请求和无效请求

无效请求有很多种类，比如通过脚本连续刷新网站首页，使得网站频繁访问数据库和其他资源，造成性能持续下降，还有些为了得到抢购商品，使用刷票软件连续请求的行为。

系统设计

业务划分：

水平划分：分拆成各个独立的子业务，相互隔离，降低数据的复杂性，但是各个系统之间存在着关联，还要通过RPC远程过程调用协议处理这些信息，比较流行的RPC有Dubbo、Thrift和Hessian等。
垂直划分：按照不相干的各个同样的系统分摊下去来进行业务处理。
水平垂直结合的划分。

数据库设计

分库
分表
MySQL优化

动静分离技术

对于互联网而言大部分数据都是静态数据，只有少数使用动态数据，动态数据的数据包很小，不会造成网络瓶颈，而静态的数据则不一样，静态数据包含图片、CSS（样式）、JavaScript（脚本）和视频等互联网的应用，尤其是图片和视频占据的流量很大，如果都从冬天服务器（比如Tomcat、WildFly和WebLogic等）获取，那么动态服务器的带宽压力会很大，这个时候应该考虑使用静态分离技术。

CDN（Content Delivery Network）内容分发网络技术，它允许企业将自己的静态数据缓存到网络CDN的节点，就近响应。
静态HTTP服务器，将静态数据分离到静态HTTP服务器上。其原理大同小异，就是将资源分配到静态服务器上，这样图片、HTML、脚本等资源都可以从静态服务器上获取，尽量使用Cookie等技术，让客户端缓存能够缓存数据，避免多次请求，降低服务器的压力。

锁和高并发

无论区分有效请求和无效请求，水平划分还是垂直划分，动静分离技术，还是数据库分表、分库等技术的应用，都无法避免动态数据，而动态数据的请求最终也会落在一台Web服务器上。高并发系统存在一个麻烦是并发数据不一致问题。

在高并发的场景下可能出现错扣红包的情况，这样就会导致数据错误。由于在一个瞬间产生很高的并发，因此除了保证数据一致性，还要尽可能地保证系统的性能，加锁会影响并发，而不加锁就难以保证数据的一致性，这就是高并发和锁的矛盾。

为了解决这对矛盾，在当前互联网系统中，大部分企业提出了悲观锁和乐观锁的概念，而对于数据库而言，如果在那么短的时间内需要执行大量SQL，对于服务器的压力可想而知，需要优化数据库的表设计、索引、SQL语句等。有些企业提出了使用Redis事务和Lua语言所提供的原子性来取代现有的数据库的技术，从而提高数据的存储响应，以应对高并发场景，严格来说也属于乐观锁的概念。

搭建抢红包开发环境和超发现象

现在模拟20万元的红包，共分为2万个红包

大小红包数据库表

create table T_RED_PACKET(
    id int(12) not null auto_increment , # 红包编号
    user_id int(12) not null , # 发红包用户
    amount decimal(16,2) not null , # 红包金额
    send_date timestamp not null , # 发红包时间
    total int(12) not null ,  # 小红包总数
    unit_amount decimal(12) not null , # 单个小红包金额
    stock int(12) not null ,  # 剩余小红包个数
    version int(12) default 0 not null , # 版本
    note varchar(256) null , # 备注
    primary key clustered(id)
);

create table T_USER_RED_PACKET(
    id int(12) not null auto_increment, # 编号
    red_packet_id int(12) not null , # 红包编号
    user_id int(12) not null , # 抢红包用户编号
    amount decimal(16,2) not null , # 抢红包金额
    grab_time timestamp not null , # 抢红包时间
    note varchar(256) null , # 备注
    primary key clustered(id)
);
insert into t_red_packet(user_id, amount, send_date, total, unit_amount, stock, note)
values (1, 200000.00, now(), 20000, 10.00, 20000, '20万元金额，2万个小红包，每个10元');

Mapper接口

package com.louris.springboot.IoCImpl.mapper;

import com.louris.springboot.IoCImpl.beans.pojo.RedPacket;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface RedPacketDao {
    RedPacket getRedPacket(Long id);
    int decreaseRedPacket(Long id);
}

package com.louris.springboot.IoCImpl.mapper;

import com.louris.springboot.IoCImpl.beans.pojo.UserRedPacket;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserRedPacketDao {
    int grapRedPacket(UserRedPacket userRedPacket);
}

Mybatis的Mapper配置文件

<?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.louris.springboot.IoCImpl.mapper.RedPacketDao">
    <!--查询红包具体信息-->
    <select id="getRedPacket" parameterType="long" resultType="com.louris.springboot.IoCImpl.beans.pojo.RedPacket">
        select id, user_id as userId, amount, send_date as sendDate, total, unit_amount as unitAmount, stock, version, note from t_red_packet where id = #{id}
    </select>
    <!--扣减抢红包库存-->
    <update id="decreaseRedPacket" parameterType="long">
        update t_red_packet set stock = stock - 1 where id = #{id}
    </update>
</mapper>

<?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.louris.springboot.IoCImpl.mapper.UserRedPacketDao">
    <insert id="grapRedPacket" useGeneratedKeys="true" keyProperty="id" parameterType="com.louris.springboot.IoCImpl.beans.pojo.UserRedPacket">
        insert into t_user_red_packet(red_packet_id, user_id, amount, grab_time, note)
        values (#{redPacketId}, #{userId}, #{amount}, now(), #{note})
    </insert>
</mapper>

Service接口

package com.louris.springboot.IoCImpl.service;

import com.louris.springboot.IoCImpl.beans.pojo.RedPacket;
import org.springframework.stereotype.Service;

public interface RedPacketService {
    RedPacket getRedPacket(Long id);
    int decreaseRedPacket(Long id);
}

package com.louris.springboot.IoCImpl.service;

public interface UserRedPacketService {
    int grapRedPacket(Long redPacketId, Long userId);
}

ServiceImpl实现类

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.RedPacket;
import com.louris.springboot.IoCImpl.mapper.RedPacketDao;
import com.louris.springboot.IoCImpl.service.RedPacketService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class RedPacketServiceImpl implements RedPacketService {

    @Autowired
    private RedPacketDao redPacketDao = null;

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public RedPacket getRedPacket(Long id) {
        return redPacketDao.getRedPacket(id);
    }

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public int decreaseRedPacket(Long id) {
        return redPacketDao.decreaseRedPacket(id);
    }
}

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.RedPacket;
import com.louris.springboot.IoCImpl.beans.pojo.UserRedPacket;
import com.louris.springboot.IoCImpl.mapper.RedPacketDao;
import com.louris.springboot.IoCImpl.mapper.UserRedPacketDao;
import com.louris.springboot.IoCImpl.service.RedPacketService;
import com.louris.springboot.IoCImpl.service.UserRedPacketService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserRedPacketServiceImpl implements UserRedPacketService {

    @Autowired
    private UserRedPacketDao userRedPacketDao = null;

    @Autowired
    private RedPacketService redPacketService = null;

    //失败
    private static final int FAILED = 0;

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public int grapRedPacket(Long redPacketId, Long userId) {
        System.out.println("enter grapRedPacket");
        //获取红包信息
        RedPacket redPacket = redPacketService.getRedPacket(redPacketId);
        //当前小红包库存大于0
        if(redPacket.getStock() > 0){
            System.out.println("enter stock");
            redPacketService.decreaseRedPacket(redPacketId);
            //生成抢红包信息
            UserRedPacket userRedPacket = new UserRedPacket();
            userRedPacket.setRedPacketId(redPacketId);
            userRedPacket.setUserId(userId);
            userRedPacket.setAmount(redPacket.getUnitAmount());
            userRedPacket.setNote("抢红包 " + redPacketId);
            System.out.println(userId);
            //插入抢红包信息
            return userRedPacketDao.grapRedPacket(userRedPacket);
        }
        //失败返回
        return FAILED;
    }
}

页面

<%--
  Created by IntelliJ IDEA.
  User: louris
  Date: 2021/10/17
  Time: 19:47
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>抢红包测试</title>
    <script src="https://code.jquery.com/jquery-3.2.0.js" type="text/javascript"></script>
    <script type="text/javascript">
        $(document).ready(function () {
            //模拟300个异步请求，进行并发
            var max = 300;
            for(var i = 1; i <= max; i ++){
                //jQuery的post请求，请注意这是异步请求
                $.post({
                    //请求抢id为1的红包
                    url: "./grapRedPacket?redPacketId=1&userId=" + i,
                    //成功后的方法
                    success: function (result) {

                    }
                });
            }
        });
    </script>
</head>
<body>

</body>
</html>

控制器

package com.louris.springboot.IoCImpl.controller;

import com.louris.springboot.IoCImpl.service.UserRedPacketService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import java.util.HashMap;
import java.util.Map;

@Controller
@RequestMapping("/userRedPacket")
public class UserRedPacketController {

    @Autowired
    private UserRedPacketService userRedPacketService = null;

    @RequestMapping("/grap")
    public ModelAndView grap(){
        ModelAndView mv = new ModelAndView();
        mv.setViewName("redPacket");
        return mv;
    }

    @RequestMapping("/grapRedPacket")
    @ResponseBody
    public Map<String, Object> grapRedPacket(Long redPacketId, Long userId){
        //抢红包
        int result = userRedPacketService.grapRedPacket(redPacketId, userId);
        Map<String, Object> retMap = new HashMap<>();
        boolean flag = result > 0;
        retMap.put("success", flag);
        retMap.put("message", flag ? "抢红包成功" : "抢红包失败");
        return retMap;
    }
}

测试结果

超发现象：比如库存还剩200个，有300个请求，最后发现发了203个红包，stock库存为-3，出现了超发！
比如库存就剩下1个红包，现在有3个请求在读取库存，不加任何措施的情况下，会出现3个请求都读取库存为1的情况，从而多减了库存，发生超发现象。

悲观锁

利用数据库的行锁for update即可。

修改mapper.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.louris.springboot.IoCImpl.mapper.RedPacketDao">
    <!--查询红包具体信息-->
    <select id="getRedPacket" parameterType="long" resultType="com.louris.springboot.IoCImpl.beans.pojo.RedPacket">
        select id, user_id as userId, amount, send_date as sendDate, total, unit_amount as unitAmount, stock, version, note from t_red_packet where id = #{id}
    </select>
    <select id="getRedPacketForUpdate" parameterType="long" resultType="com.louris.springboot.IoCImpl.beans.pojo.RedPacket">
        select id, user_id as userId, amount, send_date as sendDate, total, unit_amount as unitAmount, stock, version, note
        from t_red_packet where id = #{id} for update
    </select>
    <!--扣减抢红包库存-->
    <update id="decreaseRedPacket" parameterType="long">
        update t_red_packet set stock = stock - 1 where id = #{id}
    </update>
</mapper>

修改Mapper接口

package com.louris.springboot.IoCImpl.mapper;

import com.louris.springboot.IoCImpl.beans.pojo.RedPacket;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface RedPacketDao {
    RedPacket getRedPacket(Long id);
    RedPacket getRedPacketForUpdate(Long id); //新增
    int decreaseRedPacket(Long id);
}

修改实现类

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.RedPacket;
import com.louris.springboot.IoCImpl.mapper.RedPacketDao;
import com.louris.springboot.IoCImpl.service.RedPacketService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class RedPacketServiceImpl implements RedPacketService {

    @Autowired
    private RedPacketDao redPacketDao = null;

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public RedPacket getRedPacket(Long id) {
        //return redPacketDao.getRedPacket(id);
        return redPacketDao.getRedPacketForUpdate(id);
    }

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public int decreaseRedPacket(Long id) {
        return redPacketDao.decreaseRedPacket(id);
    }
}

测试结果

成功消除超发现象，保证了数据的一致性，但是悲观锁的性能下降很多。

频繁加锁和释放，导致事务挂起，只有抢到锁才会执行事务，性能下降，同时十分消耗资源。

注意：这里事务的隔离级别是读已提交，并且对数据加了行锁，只有在拿到锁的事务读取并减完库存后，即锁释放后，其他事务才能读取，进行更新操作。

for update用法以及加锁时机详见参考资料

乐观锁

乐观锁是一种不会阻塞其他线程并发的机制，它不会使用数据库的锁进行实现，它设计里面由于不阻塞其他线程，所以并不会引发线程频繁挂起和恢复。乐观锁使用的是CAS原理

CAS原理概述

在CAS原理中，对于多个线程共同的资源，先保存一个旧值（Old Value），比如进入线程后，查询当前存量为100个红包，那么先把旧值保存为100，然后经过一定的逻辑处理。当需要扣减红包的时候，先比较数据库当前的值和旧值是否一致，如果一致则进行扣减红包的操作，否则就认为它已经被其他线程修改过了，不再进行操作。

CAS原理并不排斥并发，也不独占资源，只是在线程开始阶段就读入线程共享数据，保存为旧值。当处理完逻辑，需要更新数据的时候，会进行一次比较，即比较各个线程当前共享的数据是否和旧值保持一致。如果一致，就开始更新数据；如果不一致，则认为该数据已经被其他线程修改了，那么就不再更新数据，可以考虑重试或者放弃。有时候可以重试，这样就是一个可重入锁，但是CAS原理会有一个问题，那就是ABA问题。

ABA问题

现有两个线程，线程1和线程2，初始化x=A，线程2修改x=B,而后又将其修改x=A，这个时候线程1需要修改x，发现与原来的值相同，所以修改。这里就出现了ABA问题，线程1并不知道x已经被修改！

可以通过version 变量，只要修改x就递增version，根据version判断是否修改，就可以避免ABA问题。

乐观锁实现抢红包业务

修改Mapper.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.louris.springboot.IoCImpl.mapper.RedPacketDao">
    <!--查询红包具体信息-->
    <select id="getRedPacket" parameterType="long" resultType="com.louris.springboot.IoCImpl.beans.pojo.RedPacket">
        select id, user_id as userId, amount, send_date as sendDate, total, unit_amount as unitAmount, stock, version, note from t_red_packet where id = #{id}
    </select>
    <select id="getRedPacketForUpdate" parameterType="long" resultType="com.louris.springboot.IoCImpl.beans.pojo.RedPacket">
        select id, user_id as userId, amount, send_date as sendDate, total, unit_amount as unitAmount, stock, version, note
        from t_red_packet where id = #{id} for update
    </select>
    <!--扣减抢红包库存-->
    <update id="decreaseRedPacket" parameterType="long">
        update t_red_packet set stock = stock - 1 where id = #{id}
    </update>
    <update id="decreaseRedPacketForVersion">
        update t_red_packet set stock = stock - 1, version = version + 1
        where id = #{id}
        and version = #{version}
    </update>
</mapper>

修改mapper接口

package com.louris.springboot.IoCImpl.mapper;

import com.louris.springboot.IoCImpl.beans.pojo.RedPacket;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface RedPacketDao {
    RedPacket getRedPacket(Long id);
    RedPacket getRedPacketForUpdate(Long id);
    int decreaseRedPacket(Long id);
    int decreaseRedPacketForVersion(Long id, Integer version);
}

修改实现类

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.RedPacket;
import com.louris.springboot.IoCImpl.mapper.RedPacketDao;
import com.louris.springboot.IoCImpl.service.RedPacketService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class RedPacketServiceImpl implements RedPacketService {

    @Autowired
    private RedPacketDao redPacketDao = null;

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public RedPacket getRedPacket(Long id) {
        return redPacketDao.getRedPacket(id);
    }
    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public RedPacket getRedPacketForUpdate(Long id) {
        return redPacketDao.getRedPacketForUpdate(id);
    }

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public int decreaseRedPacket(Long id) {
        return redPacketDao.decreaseRedPacket(id);
    }

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public int decreaseRedPacketForVersion(Long id, Integer version) {
        return redPacketDao.decreaseRedPacketForVersion(id, version);
    }
}

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.RedPacket;
import com.louris.springboot.IoCImpl.beans.pojo.UserRedPacket;
import com.louris.springboot.IoCImpl.mapper.RedPacketDao;
import com.louris.springboot.IoCImpl.mapper.UserRedPacketDao;
import com.louris.springboot.IoCImpl.service.RedPacketService;
import com.louris.springboot.IoCImpl.service.UserRedPacketService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserRedPacketServiceImpl implements UserRedPacketService {

    @Autowired
    private UserRedPacketDao userRedPacketDao = null;

    @Autowired
    private RedPacketService redPacketService = null;

    //失败
    private static final int FAILED = 0;

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public int grapRedPacket(Long redPacketId, Long userId) {
        System.out.println("enter grapRedPacket");
        //获取红包信息
        RedPacket redPacket = redPacketService.getRedPacket(redPacketId);
        //当前小红包库存大于0
        if(redPacket.getStock() > 0){
            //再次传入线程保存的version
            int update = redPacketService.decreaseRedPacketForVersion(redPacketId, redPacket.getVersion());
            //如果没有数据更新，则说明其他线程已经修改过数据，本次抢红包失败
            if(update == 0){
                return FAILED;
            }
            //生成抢红包信息
            UserRedPacket userRedPacket = new UserRedPacket();
            userRedPacket.setRedPacketId(redPacketId);
            userRedPacket.setUserId(userId);
            userRedPacket.setAmount(redPacket.getUnitAmount());
            userRedPacket.setNote("抢红包 " + redPacketId);

            //插入抢红包信息
            return userRedPacketDao.grapRedPacket(userRedPacket);
        }
        //失败返回
        return FAILED;
    }
}

测试

可以发现，能够保证数据一致性以及高性能，但是还会存在大量的红包，也就是存在大量的因为版本不一致的原因造成抢红包失败的请求，不过这个失败率太高了一点。有时候会容忍这个失败，这取决于业务的需要。

为了克服这个问题，提高成功率，还回考虑使用重入机制。也就是一旦因为版本原因没有抢到红包，则重新尝试抢红包，但是过多的重入会造成大量的SQL执行，所以目前流行的重入会加入两种限制：

按时间戳重入，也就是在一定时间戳内（比如100毫秒），不成功的会循环到成功为止，直至超时时间戳，不成功才会退出，返回失败。
按次数，比如限定3次，程序尝试超过3次抢红包后，就判定请求失败，这样有助于提高用户抢红包的成功率。

乐观锁重入机制

时间戳方案

@Override
@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
public int grapRedPacket(Long redPacketId, Long userId) {

    //记录开始时间
    long start = System.currentTimeMillis();
    //无线循环，等到成功或者时间满100毫秒退出
    while(true){
        //获取循环当前时间
        long end = System.currentTimeMillis();
        //当前时间已经超过100毫秒，返回失败
        if(end - start > 100) return FAILED;

        //获取红包信息
        RedPacket redPacket = redPacketService.getRedPacket(redPacketId);
        //当前小红包库存大于0
        if(redPacket.getStock() > 0){
            //再次传入线程保存的version
            int update = redPacketService.decreaseRedPacketForVersion(redPacketId, redPacket.getVersion());
            //如果没有数据更新，则说明其他线程已经修改过数据，则重新抢夺
            if(update == 0) continue;
            //生成抢红包信息
            UserRedPacket userRedPacket = new UserRedPacket();
            userRedPacket.setRedPacketId(redPacketId);
            userRedPacket.setUserId(userId);
            userRedPacket.setAmount(redPacket.getUnitAmount());
            userRedPacket.setNote("抢红包 " + redPacketId);
            System.out.println(userId);
            //插入抢红包信息
            return userRedPacketDao.grapRedPacket(userRedPacket);
        }else return  FAILED; //没有库存
    }
}

测试结果

从结果看，之前大量失败的场景消失了，也没有超发现象，所有红包都抢光了，避免了总是失败的结果，但是有时候时间戳并不是那么稳定，也会随着系统的空闲或者繁忙导致重试次数不一。

限制重试次数方案

@Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public int grapRedPacket(Long redPacketId, Long userId) {
        for(int i = 0; i < 3; i ++){
            //获取红包信息
            RedPacket redPacket = redPacketService.getRedPacket(redPacketId);
            //当前小红包库存大于0
            if(redPacket.getStock() > 0){
                //再次传入线程保存的version
                int update = redPacketService.decreaseRedPacketForVersion(redPacketId, redPacket.getVersion());
                //如果没有数据更新，则说明其他线程已经修改过数据，则重新抢夺
                if(update == 0) continue;
                //生成抢红包信息
                UserRedPacket userRedPacket = new UserRedPacket();
                userRedPacket.setRedPacketId(redPacketId);
                userRedPacket.setUserId(userId);
                userRedPacket.setAmount(redPacket.getUnitAmount());
                userRedPacket.setNote("抢红包 " + redPacketId);
                System.out.println(userId);
                //插入抢红包信息
                return userRedPacketDao.grapRedPacket(userRedPacket);
            }else return  FAILED; //没有库存
        }
        return FAILED;
    }

测试结果

所有红包都被抢到了，也没有超发现象，这样就可以消除大量的请求失败，避免非重入的时候大量请求失败的场景。

但是现在是使用数据库的情况，有时候并不想使用数据库作为抢红包时刻的数据保存载体，而是选择性能优于数据库的Redis。

使用Redis实现抢红包

数据库最终会将数据保存到磁盘中，而Redis使用的是内存，内存的速度比磁盘速度快得多。但是需要知道的是Redis的功能不如数据库强大，事务也不完整，因此要保证数据的正确性，数据的正确性可以通过严格的验证得以保证。而

使用注解方式配置Redis

package com.louris.springboot.IoCImpl.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.louris.springboot.utils.RedisMessageListener;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.listener.ChannelTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.Topic;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import redis.clients.jedis.JedisPoolConfig;

import javax.sql.DataSource;
import javax.xml.crypto.Data;
import java.time.Duration;
import java.util.*;

@Configuration
//@EnableCaching
@ComponentScan(basePackages = "com.louris.springboot.utils")
public class RedisConfig {

    @Bean(name = "poolConfig")
    public JedisPoolConfig getPoolConfig(){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //最大空闲数
        poolConfig.setMaxIdle(50);
        //最大连接数
        poolConfig.setMaxTotal(100);
        //最大等待时间
        poolConfig.setMaxWaitMillis(20000);
        return poolConfig;
    }
    @Bean(name = "connectionFactory")
    public JedisConnectionFactory getJedisConnectionFactory(){
        JedisConnectionFactory factory = new JedisConnectionFactory(getPoolConfig());
        factory.setHostName("localhost");
        factory.setPort(6379);
        //factory.setPassword("123456");
        factory.afterPropertiesSet(); //调用后初始化方法，没有它将抛出异常
        //factory.setPoolConfig(getPoolConfig());
        return factory;
    }

    @Bean(name = "jdkSerializationRedisSerializer")
    public JdkSerializationRedisSerializer getJdkRedisSerializer(){
        return new JdkSerializationRedisSerializer();
    }

    @Bean(name = "stringRedisSerializer")
    public StringRedisSerializer getStringRedisSerializer(){
        return new StringRedisSerializer();
    }

    @Bean(name = "redisTemplate")
    public RedisTemplate<String, String> getRedisTemplate(){
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        //设置连接工程
        redisTemplate.setConnectionFactory(getJedisConnectionFactory());
        //设置序列化器
        redisTemplate.setDefaultSerializer(getStringRedisSerializer());
        redisTemplate.setKeySerializer(getStringRedisSerializer());
        redisTemplate.setValueSerializer(getStringRedisSerializer());
        redisTemplate.setHashKeySerializer(getStringRedisSerializer());
        redisTemplate.setHashValueSerializer(getStringRedisSerializer());
        redisTemplate.setEnableTransactionSupport(true);
        return redisTemplate;
    }

    //@Bean(name = "redisCache")
    public CacheManager initRedisCacheManager(@Autowired RedisTemplate redisTemplate){
        RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(getJedisConnectionFactory());
        //启动Redis缓存的默认设置
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        //设置JDK序列化器
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(getJdkRedisSerializer()));
        //禁用前缀
        config = config.disableKeyPrefix();
        //设置1min超时
        config = config.entryTtl(Duration.ofSeconds(60));
        //创建Redis缓存管理器
        return new RedisCacheManager(writer, config);
    }

    //@Bean(name = "taskExecutor")
    public ThreadPoolTaskExecutor getExecutor(){
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(20);
        return taskExecutor;
    }

    //@Autowired
    private RedisMessageListener listener = null;

    //@Bean(name = "topicContainer")
    public RedisMessageListenerContainer getContainer(){
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(getJedisConnectionFactory());
        container.setTaskExecutor(getExecutor());
        ChannelTopic channelTopic = new ChannelTopic("chat");
        container.addMessageListener(listener, channelTopic);
        return container;
    }
}

数据存储设计

Redis并不是一个严格的事务，而且事务的功能也是有限的。加上Redis本身的命令也比较有限，功能性不强，为了增强功能性，还可以使用Lua语言。Redis中的Lua语言是一种原子性的操作，可以保证数据的一致性。依据这个原理可以避免超发现象，完成抢红包的功能，而且对于性能而言，Redis会比数据库快得多。

第一次运行Lua脚本的时候，先在Redis中编译和缓存脚本，这样就可以得到一个SHA1字符串，之后通过SHA1字符串和参数就能调用Lua脚本了。

redPacket.lua脚本

--缓存抢红包列表信息列表key
local listKey = 'red_packet_list_'..KEYS[1]
--当前被抢红包key
local redPacket = 'red_packet_'..KEYS[1]
--获取当前红包库存
local stock = tonumber(redis.call('hget', redPacket, 'stock'))
--没有库存，返回为0
if stock <= 0 then return 0 end
--库存减1
stock = stock - 1
--保存当前库存
redis.call('hset', redPacket, 'stock', tostring(stock))
--往链表中加入当前红包信息
redis.call('rpush', listKey, ARGV[1])
--如果是最后一个红包，则返回2，表示抢红包已经结束，需要将列表中的数据保存到数据库中
if stock == 0 then return 2 end
--如果并非最后一个红包，则返回1，表示抢红包成功
return 1

流程：

判断是否存在可抢的库存，如果已经没有可抢夺的红包，则返回为0，结束流程；
有可抢夺的红包，对于红包的库存减一，然后重新设置库存；
将抢红包数据保存到Redis的链表当中，链表的key为red_packet_list_{id}；
如果当前库存为0，那么返回2，这说明可以触发数据库对Redis链表数据的保存，链表的key为red_packet_list_{id}，它将保存抢红包的用户名和抢的时间；
如果当前库存不为0，那么将返回1，这说明抢红包信息保存成功。

RedisRedPackerService接口

package com.louris.springboot.IoCImpl.service;

public interface RedisRedPacketService {
    void saveUserRedPacketByRedis(Long redPacketId, Double unitAmount);
}

实现类

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.UserRedPacket;
import com.louris.springboot.IoCImpl.service.RedisRedPacketService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

@Service
public class RedisRedPacketServiceImpl implements RedisRedPacketService {
    private static final String PREFIX = "red_packet_list_";
    //每次取出1000条，避免一次取出消耗太多内存
    private static final int TIME_SIZE = 1000;

    @Autowired
    private RedisTemplate redisTemplate = null;

    @Autowired
    private DataSource dataSource = null;

    @Override
    @Async //开启新线程运行
    public void saveUserRedPacketByRedis(Long redPacketId, Double unitAmount) {
        System.out.println("开始保存数据");
        Long start = System.currentTimeMillis();
        //获取列表操作对象
        BoundListOperations ops = redisTemplate.boundListOps(PREFIX + redPacketId);
        Long size = ops.size();
        Long times = size % TIME_SIZE == 0 ? size / TIME_SIZE : size / TIME_SIZE + 1;
        int count = 0;
        List<UserRedPacket> userRedPacketList = new ArrayList<>(TIME_SIZE);
        for(int i = 0; i < times; i ++){
            //获取至多TIME_SIZE个抢红包信息
            List userIdList = null;
            if(i == 0){
                userIdList = ops.range(i * TIME_SIZE, (i + 1) * TIME_SIZE);
            }else{
                userIdList = ops.range(i * TIME_SIZE + 1, (i + 1) * TIME_SIZE);
            }
            userRedPacketList.clear();
            //保存红包信息
            for(int j = 0; j < userIdList.size(); j ++){
                String args = userIdList.get(j).toString();
                String[] arr = args.split("-");
                String userIdStr = arr[0];
                String timeStr = arr[1];
                Long userId = Long.parseLong(userIdStr);
                Long time = Long.parseLong(timeStr);
                //生成抢红包信息
                UserRedPacket userRedPacket = new UserRedPacket();
                userRedPacket.setRedPacketId(redPacketId);
                userRedPacket.setUserId(userId);
                userRedPacket.setAmount(unitAmount);
                userRedPacket.setGrabTime(new Timestamp(time));
                userRedPacket.setNote("抢红包 " + redPacketId);
                userRedPacketList.add(userRedPacket);
            }
            //插入抢红包信息
            count += executeBatch(userRedPacketList);
        }
        //删除Redis列表
        redisTemplate.delete(PREFIX + redPacketId);
        Long end = System.currentTimeMillis();
        System.out.println("保存数据结束，耗时" + (end - start) + "毫秒，共" + count + "条记录被保存。");
    }

    private int executeBatch(List<UserRedPacket> userRedPacketList){
        Connection conn = null;
        Statement stmt = null;
        int[] count = null;
        try{
            conn = dataSource.getConnection();
            conn.setAutoCommit(false);
            stmt = conn.createStatement();
            for(UserRedPacket userRedPacket:userRedPacketList){
                String sql1 = "update t_red_packet set stock = stock - 1 where id = " + userRedPacket.getRedPacketId();
                DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String sql2 = "insert into t_user_red_packet(red_packet_id, user_id, "
                        + "amount, grab_time, note)"
                        + "values(" + userRedPacket.getRedPacketId() + ", "
                        + userRedPacket.getUserId() + ", "
                        + userRedPacket.getAmount() + ","
                        + "'" + df.format(userRedPacket.getGrabTime()) + "',"
                        + "'" + userRedPacket.getNote() + "')";
                stmt.addBatch(sql1);
                stmt.addBatch(sql2);
            }
            //执行批量
            count = stmt.executeBatch();
            //提交事务
            conn.commit();
        }catch (SQLException e){
            throw new RuntimeException("抢红包批量执行程序错误");
        }finally {
            try{
                if(conn != null && !conn.isClosed()){
                    conn.close();
                }
            }catch (SQLException e){
                e.printStackTrace();
            }
        }
        //返回插入抢红包数据记录
        return count.length / 2;
    }
}

异步配置类

package com.louris.springboot.IoCImpl.config;

import org.aspectj.apache.bcel.generic.TABLESWITCH;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurerSupport;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@Configuration
@EnableAsync
public class AsyncConfig extends AsyncConfigurerSupport {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(5);
        taskExecutor.setMaxPoolSize(10);
        taskExecutor.setQueueCapacity(200);
        taskExecutor.initialize();
        return taskExecutor;
    }
}

抢红包实现类

package com.louris.springboot.IoCImpl.impl;

import com.louris.springboot.IoCImpl.beans.pojo.RedPacket;
import com.louris.springboot.IoCImpl.beans.pojo.UserRedPacket;
import com.louris.springboot.IoCImpl.mapper.RedPacketDao;
import com.louris.springboot.IoCImpl.mapper.UserRedPacketDao;
import com.louris.springboot.IoCImpl.service.RedPacketService;
import com.louris.springboot.IoCImpl.service.RedisRedPacketService;
import com.louris.springboot.IoCImpl.service.UserRedPacketService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import redis.clients.jedis.Jedis;

@Service
public class UserRedPacketServiceImpl implements UserRedPacketService {

    ......

    @Autowired
    @Qualifier("redisTemplate")
    private RedisTemplate redisTemplate = null;

    @Autowired
    private RedisRedPacketService redisRedPacketService = null;

    //Lua脚本
    String script = "local listKey = 'red_packet_list_'..KEYS[1] \n"
            + "local redPacket = 'red_packet_'..KEYS[1] \n"
            + "local stock = tonumber(redis.call('hget', redPacket, 'stock')) \n"
            + "if stock <= 0 then return 0 end \n"
            + "stock = stock - 1 \n"
            + "redis.call('hset', redPacket, 'stock', tostring(stock)) \n"
            + "redis.call('rpush', listKey, ARGV[1]) \n"
            + "if stock == 0 then return 2 end \n"
            + "return 1 \n";

    //在缓存Lua脚本后，使用该变量保存Redis返回的32位SHA1编码，使用它去执行缓存的Lua脚本
    String sha1 = null;

    @Override
    public Long grapRedPacketByRedis(Long redPacketId, Long userId) {
        //当前抢红包用户和日期信息
        String args = userId + "-" + System.currentTimeMillis();
        Long result = null;
        //获取底层Redis操作对象
        Jedis jedis = (Jedis) redisTemplate.getConnectionFactory().getConnection().getNativeConnection();
        try{
            //如果脚本没有加载过，那么进行加载，这样就会返回一个sha1编码
            if(sha1 == null){
                sha1 = jedis.scriptLoad(script);
            }
            //执行脚本，返回结果
            Object res = jedis.evalsha(sha1, 1, redPacketId + "", args);
            result = (Long) res;

            //返回2时为最后一个红包，此时将抢红包信息通过异步保存到数据库中
            if(result == 2){
                //获取单个小红包金额
                String unitAmountStr = jedis.hget("red_packet_" + redPacketId, "unit_amount");
                System.out.println(unitAmountStr);
                //触发保存数据库操作
                Double unitAmount = Double.parseDouble(unitAmountStr);
                System.out.println("thread_name = " + Thread.currentThread().getName());
                redisRedPacketService.saveUserRedPacketByRedis(redPacketId, unitAmount);
            }
        }finally {
            //确保jedis顺利关闭
            if(jedis != null && jedis.isConnected()){
                jedis.close();
            }
        }
        return result;
    }
}

页面

<%--
  Created by IntelliJ IDEA.
  User: louris
  Date: 2021/10/17
  Time: 19:47
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>抢红包测试</title>
    <script src="https://code.jquery.com/jquery-3.2.0.js" type="text/javascript"></script>
    <script type="text/javascript">
        $(document).ready(function () {
            //模拟300个异步请求，进行并发
            var max = 300;
            for(var i = 1; i <= max; i ++){
                //jQuery的post请求，请注意这是异步请求
                $.post({
                    //请求抢id为1的红包
                    url: "./grapRedPacketByRedis?redPacketId=1&userId=" + i,
                    //成功后的方法
                    success: function (result) {

                    }
                });
            }
        });
    </script>
</head>
<body>

</body>
</html>

控制类

@RequestMapping("/grapRedPacketByRedis")
    @ResponseBody
    public Map<String, Object> grapRedPacketByRedis(Long redPacketId, Long userId){
        Map<String, Object> resultMap = new HashMap<>();
        Long result = userRedPacketService.grapRedPacketByRedis(redPacketId, userId);
        boolean flag = result > 0;
        resultMap.put("result", flag);
        resultMap.put("message", flag ? "抢红包成功" : "抢红包失败");
        return resultMap;
    }

测试

127.0.0.1:6379> hset red_packet_1 stock 200
(integer) 1
127.0.0.1:6379> hset red_packet_1 unit_amount 10
(integer) 1

10
thread_name = http-nio-8081-exec-4
2021-10-18 23:12:52.008 [http-nio-8081-exec-4] INFO  o.s.scheduling.concurrent.ThreadPoolTaskExecutor - Initializing ExecutorService
开始保存数据
保存数据结束，耗时412毫秒，共200条记录被保存。

并发思考

知识点：

仅读已提交隔离级别

如前面所述，减库存事务包含两步：读库存和减库存；结果是将发生超发现象。

读已提交对应二级封锁协议，以库存为1，有两个请求并发减库存为例：
事务1和事务2几乎同时对数据行r加S锁，都读到库存为1，随后都释放S锁，然后事务1先减库存加X锁，期间事务2阻塞，事务1释放X锁后，事务2才能修改数据，这样就造成了两次减库存，超发了！

for update悲观锁实现

乐观锁for update是对读取数据加X锁，只有update或者事务结束了才会释放X锁。
以库存为1，有两个请求并发减库存为例：
事务1先读数据，加了X锁，事务2这时候读阻塞，事务1更新完数据或者事务回退释放X锁后，事务2才能读库存和写库存，保证了数据一致性。

CAS乐观锁实现

以库存为1，有两个请求并发减库存为例：
事务1和事务2几乎同时对数据行r加S锁，都读到库存为1，随后都释放S锁，然后事务1先减库存加X锁，期间事务2减库存阻塞

如果事务1减库存成功，释放X锁后，事务2再次读取库存以及version，发现不一致，不进行减库存；
如果事务1减库存失败回退，释放X锁后，事务2再次读取库存以及version，发现一致，进行减库存；
这样也保证了数据的一致性，同时并没有像悲观锁那样更耗时。

前言

Java设计模式

反射

反射技术

静态代理

动态代理

JDK动态代理

Cglib动态代理

拦截器

责任链模式/多级代理

观察者模式

建造者模式

简单实现以及建造者模式对比

静态内部类的实现

互联网持久层框架——MyBatis

认识MyBatis核心组件

Mybatis的核心组件

SqlSessionFactory

XML构建方式（推荐）

代码构建方式

SqlSession

Mapper映射器

POJO和映射接口

XML映射文件实现

注解实现

SqlSession发送SQL

用Mapper接口发送SQL（推荐）

生命周期

实例

log4j.properties

mybatis-config.xml

RoleMapper.xml

Role

RoleMapper

SqlSessionFactoryUtil

运行结果

MyBatis配置

properties属性

property子元素

使用properties文件

使用程序传递方式传递参数

优先级

settings设置

typeAliases别名

系统定义别名

自定义别名

typeHandler类型转换器

系统定义的typeHandler

自定义typeHandler

MyTypeHandler

RoleMapper.xml

RoleMapper

SqlSessionFactoryUtils

运行结果

枚举typeHandler

UserMapper.xml

EnumOrdinalTypeHandler方式

EnumTypeHandler方式

SexEnum

User

UserMapper

mybatis-config.xml

SqlSessionFactoryUtils

运行结果

结果①

结果②

自定义枚举typeHandler

文件操作 （不太常用）

ObjectFactory（对象工厂）

MyObjectFactory

mybatis-config.xml

运行结果

插件

enviroments（运行环境）

transactionManager（事务管理器）

简介

自定义事务工厂

environment数据源环境

UNPOOLED

POOLED

文件操作（不太常用）