Spring5之IOC\AOP\事务\jdbcTemplete

Spring概述

Spring是轻量级的开源JavaEE框架，可以解决企业应用开发的复杂性。Spring有两个核心部分，即IOC和AOP。

IOC：控制反转，把创建对象的过程交给Spring进行管理。
AOP：面向切面编程，不修改源代码的前提下进行功能增强。

Spring框架的特点：

方便解耦，简化开发。利用IOC可以降低硬编码程序的耦合度。
支持AOP编程。
方便程序的测试，Spring支持JUint4，通过注解即可进行测试。
方便集成各种优秀框架，例如MyBatis等。
降低JavaEE各类API使用难度。
方便进行事务操作。

Spring5 Demo

五个基本jar包：

commons-logging-1.2.jar：日志
spring-beans-5.2.7.RELEASE.jar
spring-context-5.2.7.RELEASE.jar
spring-core-5.2.7.RELEASE.jar
spring-expression-5.2.7.RELEASE.jar

1、创建对象类

public class User {
    
    
    public void add(){
    
    
        System.out.println("hello world");
    }
}

2、Spring5配置文件

<?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="user" class="spring5.User">
    </bean>
</beans>

3、测试类（通过Spring5获取对象）

@Test
public void test1(){
    
    
    //1.加载spring配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("config/bean1.xml");
    //2.获取配置创建的对象，第一个参数是Spring5配置的bean的id，第二个参数是对象的实体类
    User user = context.getBean("user", User.class);
    user.add();

}

IOC容器

底层原理

IOC是控制反转，把对象的创建和对象之间的调用过程，交给Spring进行管理。使用IOC的目的就是降低程序之间的耦合度。底层三大技术：xml解析、工厂模式、反射。

IOC过程：

第一步，XML配置我呢见，配置创建的对象。

<bean id="dao" class="com.xingyu.UserDao"></bean>

第二步，创建工厂类

public class UserFactory {
    
    
    public static UserDao getDao() throws Exception{
    
    
        String classValue = 配置文件中class属性值，即com.xingyu.UserDao;//1.XML解析
        Class clazz = Class.forName(classValue);//2.通过反射创建对象
        return (UserDao) clazz.newInstance();
    }
}

IOC接口

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。

Spring提供IOC容器实现两种方式（两个接口）：

**BeanFactory：**IOC容器基本实现，是Spring内部使用的接口，一般不提供开发人员进行使用。
- 加载配置文件时不会创建对象，在获取对象或者适用对象时才创建
**ApplicationContext：**是BeanFactory的子接口，提供更多更强大的功能，一般由开发人员使用。
- 加载配置文件时就会把配置文件中的对象进行创建
- 实现类：
  - new FileSystemXmlApplicationContext(磁盘路径)
  - new ClassPathXmlApplicationContext(内路径，即src下)

Bean管理指的是两个操作：（1）Spring创建对象（2）Spirng注入属性

Bean管理操作有两种方式：（1）基于 xml 配置文件方式实现（2）基于注解方式实现

IOC操作Bean管理（XML）

<bean id="dao" class="com.xingyu.UserDao"></bean>

在 spring 配置文件中，使用 bean标签，标签里面添加对应属性，就可以实现对象创建。在bean标签有很多属性，常用的属性

id 属性：唯一标识
class 属性：类全路径（包类路径）
创建对象时候，默认是执行无参数构造方法完成对象创建

DI，依赖注入，即注入属性，是在创建对象的前提下完成。基于 xml 方式注入属性：（1）使用 set 方法进行注入；（2）使用有参数构造进行注入；

注入属性——使用set方法进行注入：即在实体类中实现属性set方法，调用此set方法给属性赋值。

实现过程：

第一步、创建类，定义属性和对应的 set 方法

public class Book {
    
     
    //创建属性 
    private String bname; 
    private String bauthor; 
    //创建属性对应的set方法 
    public void setBname(String bname) {
    
     
        this.bname = bname;
	}
    public void setBauthor(String bauthor) {
    
     
    	this.bauthor = bauthor;
    } 
}

第二步、在 spring 配置文件配置对象创建，配置属性注入

<bean id="book" class="com.xingyu.entity.Book"> 
    <!--使用property完成属性注入 name：类里面属性名称 value：向属性注入的值
--> <property name="bname" value="易筋经"></property>
    <property name="bauthor" value="达摩老祖"></property>
</bean>

注入属性——使用有参数构造进行注入：

实现过程：

第一步、创建类，定义属性，创建属性对应有参数构造方法

第二步、在 spring 配置文件中进行配置

<bean id="orders" class="com.xingyu.entity.Orders"> 
    <constructor-arg name="oname" value="电脑"></constructor-arg>
    <constructor-arg name="address" value="China"></constructor-arg>
</bean>

注入属性——给属性注入特殊值：

1、null值：

<property name="address"> 
    <null/>
</property>

2、属性值包含特殊符号，把带特殊符号内容写到CDATA

<property name="address"> 
    <value><![CDATA[<<南京>>]]></value>
</property>

注入属性——外部Bean：

public class UserService {
    
    

    //创建UserDao类型属性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
    
    
        this.userDao = userDao;
    }

    public void add() {
    
    
        System.out.println("service add...............");
        userDao.update();
    }
}

<!--1 service和dao对象创建-->
<bean id="userService" class="service.UserService">
    <!--注入userDao对象
        name属性：类里面属性名称
        ref属性：创建userDao对象bean标签id值
    -->
    <property name="userDao" ref="userDaoImpl"/>
</bean>
<bean id="userDaoImpl" class="dao.UserDaoImpl"/>

注入属性——内部Bean：

在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示。

public class Emp {
    
    
    private String ename;
    private String gender;
    //员工属于某一个部门，使用对象形式表示
    private Dept dept;
	...
    //get、set

}

<!--内部bean-->
<bean id="emp" class="bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--设置对象类型属性-->
    <!--这是内部Bean的方式，使用之前的外部Bean，用ref引入也可以-->
    <property name="dept">
        <bean id="dept" class="bean.Dept">
            <property name="dname" value="安保部"></property>
        </bean>
    </property>
</bean>

注入属性——级联赋值：

//这种写法，需要在包含dept对象属性的emp类中生成dept的get方法
public Dept getDept() {
    
    
    return dept;
}

<!--级联赋值-->
<bean id="emp" class="bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>
    <property name="dept.dname" value="技术部"></property>
</bean>
<bean id="dept" class="bean.Dept">
    <property name="dname" value="财务部"></property>
</bean>

注入属性——集合属性：

<!--1 集合类型属性注入-->
<bean id="stu" class="collectiontype.Stu">
    <!--数组类型属性注入-->
    <property name="courses">
        <array>
            <value>java课程</value>
            <value>数据库课程</value>
        </array>
    </property>
    <!--list类型属性注入-->
    <property name="list">
        <list>
            <value>张三</value>
            <value>小三</value>
        </list>
    </property>
    <!--map类型属性注入-->
    <property name="maps">
        <map>
            <entry key="JAVA" value="java"></entry>
            <entry key="PHP" value="php"></entry>
        </map>
    </property>
    <!--set类型属性注入-->
    <property name="sets">
        <set>
            <value>MySQL</value>
            <value>Redis</value>
        </set>
    </property>
    
    
    <!--创建多个course对象-->
    <bean id="course1" class="collectiontype.Course">
        <property name="cname" value="Spring5框架"></property>
    </bean>
    <bean id="course2" class="collectiontype.Course">
        <property name="cname" value="MyBatis框架"></property>
    </bean>
    <!--注入list集合类型，值是对象-->
    <property name="courseList">
        <list>
            <ref bean="course1"></ref>
            <ref bean="course2"></ref>
        </list>
    </property>
</bean>

IOC操作Bean（FactoryBean）

Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）

普通 bean：在配置文件中定义 bean 类型就是返回类型
工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样
- 第一步创建类，让这个类作为工厂 bean，实现接口 FactoryBean
- 第二步实现接口里面的方法，在实现的方法中定义返回的 bean类型

public class MyBean implements FactoryBean<Course> {
    
     
//定义返回bean 
    @Override 
    public Course getObject() throws Exception {
    
     
        Course course = new Course(); 
        course.setCname("abc"); return course;
    }
    @Override 
    public Class<?> getObjectType() {
    
     
        return null;
    }
    @Override public boolean isSingleton() {
    
     
        return false;
    }
}

Bean作用域

在 Spring 里面，默认情况下，bean 是单实例对象

设置单实例还是多实例：

在 spring 配置文件 bean标签里面有属性（scope）用于设置单实例还是多实例
scope 属性值：
- 第一个值默认值，singleton，表示是单实例对象；
- 第二个值 prototype，表示是多实例对象
- request：每次创建对象会放在request域中。（了解）
- session：每次创建对象会放在session域中。（了解）

singleton和 prototype 区别：

singleton单实例，prototype 多实例
设置 scope 值是 singleton时候，加载 spring 配置文件时候就会创建单实例对象，设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用 getBean方法时候创建多实例对象

Bean生命周期

生命周期即从对象创建到对象销毁的过程。

bean 生命周期：

通过构造器创建 bean 实例（默认无参数构造、工厂模式）
为 bean的属性设置值和对其他 bean引用（调用 set 方法）
调用 bean的初始化的方法（需要进行配置初始化的方法）
bean可以使用了（对象获取到了）
当容器关闭时候，调用 bean的销毁的方法（需要进行配置销毁的方法）

<bean id="orders" class="com.atguigu.spring5.bean.Orders" initmethod="initMethod" destroy-method="destroyMethod"> 
    <property name="oname" value="手机"></property>
</bean>

bean 的后置处理器，bean 生命周期有七步：

通过构造器创建 bean 实例（无参数构造）
为 bean的属性设置值和对其他 bean引用（调用 set 方法）
把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization
调用 bean的初始化的方法（需要进行配置初始化的方法）
把 bean实例传递 bean后置处理器的方法 postProcessAfterInitialization
bean可以使用了（对象获取到了）
当容器关闭时候，调用 bean的销毁的方法（需要进行配置销毁的方法）

public class MyBeanPost implements BeanPostProcessor {
    
     
    @Override 
    public Object postProcessBeforeInitialization(Object bean, String beanName)throws BeansException{
    
     
        System.out.println("在初始化之前执行的方法"); 
        return bean;
    }
    @Override 
    public Object postProcessAfterInitialization(Object bean, String beanName)throws BeansException {
    
     
        System.out.println("在初始化之后执行的方法");
        return bean;
    } 
}

XML自动装配

根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入。

bean标签属性autowire，配置自动装配，autowire属性常用两个值：

byName根据属性名称注入，注入值bean的id值和类属性名称一样
byType根据属性类型注入

1、根据属性名称自动注入：

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

2、根据属性类型自动注入：

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType"></bean> 
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

IOC操作Bean（注解）

注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…)
使用注解，注解作用在类上面，方法上面，属性上面
使用注解目的：简化 xml 配置

Spring 针对 Bean 管理中创建对象提供注解，这四个注解功能是一样的，都可以用来创建 bean实例：

@Component
@Service：建议用在Service层
@Controller：建议用在Web层
@Repository：建议用在DAO层

基于注解方式实现对象创建：

第一步、引入依赖 spring-aop-5.2.6.RELEASE.jar

第二步、开启组件扫描：

<context:component-scan base-package="com.atguigu"></context:component-scan>

第三步、创建类，在类上面添加创建对象注解（在注解里面value属性值可以省略不写，默认值是类名称，首字母小写）

@Component(value = "userService")  //相当于手动装配的<bean id="userService" class=".."/> 
public class UserService {
    
     
    public void add() {
    
     
        System.out.println("service add.......");
    } 
}

开启组件扫描细节配置

<!--示例1 use-default-filters="false" 表示现在不使用默认filter，自己配置filter 
		 context:include-filter ，设置扫描哪些内容
		下述表示只扫描带Controller注解的类
-->
<context:component-scan base-package="com.atguigu" use-defaultfilters="false"> 
   <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> 
</context:component-scan>
<!--示例2 下面配置扫描包所有内容 
		 context:exclude-filter： 设置哪些内容不进行扫描
		下述表示不扫描带Controller注解的类
--> 
<context:component-scan base-package="com.atguigu"> 
   <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

注解实现属性注入

1、@Autowired：根据属性类型进行自动装配

创建 service 和 dao对象，在 service 和 dao类添加创建对象注解
在 service 注入 dao 对象，在 service 类添加 dao类型属性，在属性上面使用注解

@Service 
public class UserService {
    
     
    //定义dao类型属性 //不需要添加set方法 //添加注入属性注解 
    @Autowired 
    private UserDao userDao;
    public void add() {
    
     
        System.out.println("service add......."); 
        userDao.add();
    } 
}

2、@Qualifier：根据名称进行注入。

这个@Qualifier 注解的使用，和上面@Autowired 一起使用。因为如果存在多个类型相同的属性，根据类型注入会失败；所以也要根据名称注入。

@Autowired //根据类型进行注入 
@Qualifier(value = "userDaoImpl1") //根据名称进行注入 
private UserDao userDao;

3、@Resource：可以根据类型注入，可以根据名称注入

//@Resource无参数时是根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入 
private UserDao userDao;

4、@Value：注入普通类型属性

@Value(value = "abc") 
private String name;

完全注解开发：

1、创建配置类，替代 xml 配置文件

@Configuration //作为配置类，替代xml配置文件 
@ComponentScan(basePackages = {
    
    "com.atguigu"}) //配置扫描的包
public class SpringConfig {
    
     
}

2、编写测试类

@Test 
public void testService() {
    
     
    //加载配置类 
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = context.getBean("userService",UserService.class);
    System.out.println(userService); userService.add();
}

AOP

AOP，面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

通俗地讲：即不通过修改源代码的方式，在主干功能里面添加新功能。

AOP 底层使用动态代理，有两种情况动态代理

第一种，有接口情况，使用 JDK 动态代理，属于创建接口实现类代理对象，增强类的方法
第二种，没有接口情况，使用 CGLIB 动态代理，属于创建子类的代理对象，增强类的方法

AOP操作术语

连接点：类里面可以被增强的方法称作连接点
切入点：实际被真正增强的方法称作切入点
通知（增强）：实际增强的逻辑部分称为通知（增强）。通知有多种类型：
- 前置通知：切入点之前执行的增强
- 后置通知：切入后之前执行的增强
- 环绕通知：切入点之前和之后都执行的增强
- 异常通知：出现异常时执行的增强
- 最终通知：类似try-catch-finally中的finally，无论如何都会执行的增强
切面：动作，把通知应用到切入点的过程称作切面

AspectJ

Spring框架一般基于AspectJ实现AOP操作。AspectJ 不是 Spring 组成部分，是独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP操作

基于 AspectJ 实现 AOP 操作：

基于 xml 配置文件实现
基于注解方式实现（使用）

切入点表达式：

切入点表达式作用：知道对哪个类里面的哪个方法进行增强
语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
举例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强：execution(* com.atguigu.dao.BookDao.add(…))
举例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强：execution(* com.atguigu.dao.BookDao.* (…))
举例 3：对 com.atguigu.dao包里面所有类，类里面所有方法进行增强 execution(* com.atguigu.dao.. (…))

AspectJ 注解

1、创建类，在类里面定义方法

public class User {
    
     
    public void add() {
    
     
        System.out.println("add.......");
    } 
}

2、创建增强类（编写增强逻辑），在增强类里面，创建方法，让不同方法代表不同通知类型

public class UserProxy {
    
     
    public void before() {
    
    //前置通知 
        System.out.println("before......");
    } 
    public void after() {
    
    //后置通知 
        System.out.println("before......");
    } 
    ...
}

3、进行通知的配置

（1）在 spring配置文件中，开启注解扫描

<?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:context="http://www.springframework.org/schema/context" 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/context
http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 开启注解扫描 --> 
    <context:component-scan basepackage="com.atguigu.spring5.aopanno"></context:component-scan>

（2）使用注解创建 User 和 UserProxy 对象

@Component
public class User {
    
     
    public void add() {
    
     
        System.out.println("add.......");
    } 
}
@Component
public class UserProxy {
    
     
    public void before() {
    
    //前置通知 
        System.out.println("before......");
    } 
}

（3）在增强类上面添加注解 @Aspect

@Component
@Aspect
public class UserProxy {
    
     
    public void before() {
    
    //前置通知 
        System.out.println("before......");
    } 
}

（4）在 spring 配置文件中开启生成代理对象

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4、配置不同类型的通知

（1）在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

@Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void before() {
    
    ...}
@AfterReturning(value = "execution(*com.atguigu.spring5.aopanno.User.add(..))")
public void afterReturning() {
    
    ...}
@After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void after() {
    
    ...}
@AfterThrowing(value = "execution(*com.atguigu.spring5.aopanno.User.add(..))")
public void afterThrowing() {
    
    ...}
@Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    
     
    System.out.println("环绕之前........."); 
    //被增强的方法执行 
    proceedingJoinPoint.proceed(); 
    System.out.println("环绕之后.........");
}

5、相同的切入点抽取

@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void pointdemo() {
    
     }
//前置通知 //@Before注解表示作为前置通知
@Before(value = "pointdemo()") 
public void before() {
    
     
	System.out.println("before.........");
}

6、有多个增强类对同一个方法进行增强，设置增强类优先级，在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高

@Component 
@Aspect
@Order(1) 
public class PersonProxy{
    
    ...}

7、完全使用注解开发，创建配置类，不需要创建 xml 配置文件

@Configuration 
@ComponentScan(basePackages = {
    
    "com.atguigu"}) 
@EnableAspectJAutoProxy(proxyTargetClass = true) //代替<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
public class ConfigAop {
    
     ... }

AspectJ 配置文件

1、创建两个类，增强类和被增强类，创建方法

2、在 spring 配置文件中创建两个类对象

<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean> 
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>

3、在 spring 配置文件中配置切入点

<aop:config> 
    <!--切入点--> 
    <aop:pointcut id="p" expression="execution(*com.atguigu.spring5.aopxml.Book.buy(..))"/> 
    <!--配置切面--> 
    <aop:aspect ref="bookProxy"> 
        <!--增强作用在具体的方法上--> 
        <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect> 
</aop:config>

JdbcTemplate

Spring框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作。

1、引入jar包或依赖

2、在 spring 配置文件配置数据库连接池

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="url" value="jdbc:mysql:///user_db" /> 
    <property name="username" value="root" />
    <property name="password" value="root" /> 
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
</bean>

3、配置 JdbcTemplate 对象，注入 DataSource

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 
    <!--注入dataSource--> 
    <property name="dataSource" ref="dataSource"></property>
</bean>

4、创建 service 类，创建 dao类，在 dao注入 jdbcTemplate 对象

记得先添加组件扫描相关配置文件：

<context:component-scan base-package="com.atguigu"></context:component-scan>

jdbcTemplate进行CRUD：

@Service 
public class BookService {
    
     
	//注入dao 
	@Autowired 
	private BookDao bookDao;
}

@Repository 
public class BookDaoImpl implements BookDao {
    
     
	//注入JdbcTemplate 
	@Autowired 
	private JdbcTemplate jdbcTemplate;
    //添加
	@Override 
	public void add(Book book) {
    
     
    	//1 创建sql语句 
    	String sql = "insert into t_book values(?,?,?)"; 
    	//2 调用方法实现 
    	Object[] args = {
    
    book.getUserId(), book.getUsername(),book.getUstatus()}; 
    	int update = jdbcTemplate.update(sql,args);
    	System.out.println(update); 
	}
    //更新
    @Override 
    public void updateBook(Book book) {
    
     
        String sql = "update t_book set username=?,ustatus=? where user_id=?"; 
        Object[] args = {
    
    book.getUsername(), book.getUstatus(),book.getUserId()}; 
        int update = jdbcTemplate.update(sql, args); 
        System.out.println(update);
    }
    //删除
    @Override public void delete(String id) {
    
     
        String sql = "delete from t_book where user_id=?"; 
        int update = jdbcTemplate.update(sql, id); 
        System.out.println(update);
    }
    //查找特定值，比如数量
    @Override 
    public int selectCount() {
    
    
        String sql = "select count(*) from t_book"; 
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class); 
        return count;
    }
    //根据id查询一个
    @Override 
    public Book findBookInfo(String id) {
    
     
        String sql = "select * from t_book where user_id=?"; //调用方法 
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id); 
        return book;
    }
    //批量添加 
    @Override 
    public void batchAddBook(List<Object[]> batchArgs) {
    
     
        String sql = "insert into t_book values(?,?,?)"; 
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

}

事务

事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败。典型场景：银行转账。

事务四个特性（ACID）：原子性、一致性、隔离性、持久性

事务操作过程：

开启事务操作
进行业务操作
未发生异常，提交事务；发生异常，回滚事务

事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）

在 Spring 进行事务管理操作，有两种方式：编程式事务管理和声明式事务管理（使用）。

声明式事务管理

在 Spring 进行声明式事务管理，底层使用 AOP原理。

基于注解方式（使用）
基于 xml 配置文件方式

事务操作：

1、在 spring 配置文件配置事务管理器

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

2、在 spring 配置文件，开启事务注解

（1）在 spring 配置文件引入名称空间 tx

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

（2）开启事务注解

<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

3、在 service 类上面（或者 service 类里面方法上面）添加事务注解

@Transactional，这个注解添加到类上面，也可以添加方法上面
如果把这个注解添加类上面，这个类里面所有的方法都添加事务
如果把这个注解添加方法上面，为这个方法添加事务

@Service
@Transactional(readOnly = false,timeout = -1,propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {
    
    
    ...
}

其中的参数说明：

propagation：事务传播行为。多事务方法直接进行调用，这个过程中事务是如何进行管理的
ioslation：事务隔离级别
timeout：超时时间
- 事务需要在一定时间内进行提交，如果不提交进行回滚
- 默认值是 -1 ，设置时间以秒单位进行计算
readOnly：是否只读
- 读：查询操作，写：添加修改删除操作
- readOnly 默认值 false，表示可以查询，可以添加修改删除操作
- 设置 readOnly 值是 true，设置成 true 之后，只能查询
rollbackFor：回滚，设置出现哪些异常进行事务回滚
noRollbackFor：不回滚。设置出现哪些异常不进行事务回滚

完全注解声明式事务管理

@Configuration //配置类
@ComponentScan(basePackages = "com.xingyu") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
    
    

    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource() {
    
    
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///user_db");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }

    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
    
    
        //到ioc容器中根据类型找到dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    //创建事务管理器
//    @Bean
//    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
    
    
//        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
//        transactionManager.setDataSource(dataSource);
//        return transactionManager;
//    }
}

Spring5新特性

1、Spring 5.0 框架自带了通用的日志封装

Spring5 已经移除 Log4jConfigListener，官方建议使用 Log4j2
Spring5 框架整合 Log4j2

log4j2.xml配置文件信息：

<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
<configuration status="INFO">
    <!--先定义所有的appender-->
    <appenders>
        <!--输出日志信息到控制台-->
        <console name="Console" target="SYSTEM_OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>

手动在控制台输出日志：

public class UserLog {
    
    
    private static final Logger log = LoggerFactory.getLogger(UserLog.class);
    public static void main(String[] args) {
    
    
        log.info("hello log4j2");
        log.warn("hello log4j2");
    }
}

2、Spring5 框架核心容器支持@Nullable 注解

@Nullable 注解可以使用在方法上面，属性上面，参数上面，表示方法返回可以为空，属性值可以为空，参数值可以为空
注解用在方法上面，方法返回值可以为空
注解使用在方法参数里面，方法参数可以为空
注解使用在属性上面，属性值可以为空

3、Spring5核心容器支持函数式风格GenericApplicationContext

4、Spring5 支持整合 JUnit5

SpringWebflux

SpringWebflux 是 Spring5 添加新的模块，用于 web 开发，功能和 SpringMVC 类似，Webflux 使用响应式编程。

传统 web 框架，比如 SpringMVC，这些基于 Servlet 容器，Webflux 是一种异步非阻塞的框架，异步非阻塞的框架在 Servlet3.1 以后才支持，核心是基于 Reactor 的相关 API 实现的。

异步和同步针对调用者，调用者发送请求，如果等着对方回应之后才去做其他事情就是同步，如果发送请求之后不等着对方回应就去做其他事情就是异步
阻塞和非阻塞针对被调用者，被调用者受到请求之后，做完请求任务之后才给出反馈就是阻塞，受到请求之后马上给出反馈然后再去做事情就是非阻塞

Webflux 特点：

非阻塞式：在有限资源下，提高系统吞吐量和伸缩性，以 Reactor 为基础实现响应式编程
函数式编程：Spring5 框架基于 java8，Webflux 使用 Java8 函数式编程方式实现路由请求

响应式编程：

响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。电子表格程序就是响应式编程的一个例子。单元格可以包含字面值或类似"=B1+C1"的公式，而包含公式的单元格的值会依据其他单元格的值的变化而变化。