Spring - AdRaintyの小窝

1 Spring 框架概述

1.1 概述

Spring是轻量级的开源的JavaEE框架，可以解决企业应用开发的复杂性

Spring有两个核心部分：IOC和Aop

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

Spring特点

方便解耦，简化开发
Aop编程支持
方便程序测试
方便和其他框架进行整合
方便进行事务操作
降低API开发难度

1.2 Spring入门案例

Spring框架示意图如下：

1.2.1 导入所需核心jar包

我们使用需要导出核心包：

spring-beans-5.2.6.RELEASE
spring-context-5.2.6.RELEASE
spring-core-5.2.6.RELEASE
spring-expression-5.2.6.RELEASE

还需要导入日志包commons-logging-1.1.1

1.2.2 创建spring 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对象 其中class是类名-->
    <bean id="user" class="com.adrainty.test01.User"></bean>
</beans>

1.2.3 示例代码

public class TestSpring5 {
    @Test
    public void testAdd(){
        // 加载Spring配置文件
        ApplicationContext context =
                new FileSystemXmlApplicationContext("xml/bean01.xml");
		
        // 获取配置的对象
        User user = context.getBean("user", User.class);
        user.add();
    }
}

2 IOC底层原理

2.1 IOC介绍

控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理
使用IOC目的：为了耦合度降低

入门案例就是IOC的体现

IOC底层原理包括xml解析、工厂模式、反射

xml配置文件，配置创建的对象
有service和dao类，创建工厂类
通过反射创建对象

2.2 IOC的接口

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

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

BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用
ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用

BeanFactory加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象

ApplicationContext加载配置文件时候就会把在配置文件对象进行创建

ApplicationContext context =
                new FileSystemXmlApplicationContext("xml/bean01.xml");

ApplicationContext有实现类

FileSystemXmlApplicationContext：文件路径
ClassPathXmlApplicationContext：类路径

2.3 IOC操作Bean管理的概念

Bean管理指的是两个操作

Spring创建对象
Spirng注入属性

Bean管理操作有两种方式

基于xml配置文件方式实现
基于注解方式实现

2.3.1 IOC操作Bean管理（基于xml方式）

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

<!--创建bean对象-->
<bean id="user" class="com.adrainty.test01.User"></bean>

bean标签有很多属性，介绍常用的属性

id属性：唯一标识
class属性：类全路径（包类路径）

创建对象时候，默认也是执行无参数构造方法完成对象创建

基于XML方式注入属性有两种方式

DI：依赖注入，就是注入属性

方法：

创建属性和属性对应的set方法
配置对象创建(xml bean标签)
属性注入(xml property标签)

// Book.java
public class Book {
    private String bname;

    public void setBname(String bname){
        this.bname = bname;
    }
}

<!-- bean.xml-->
<bean id="book" class="com.adrainty.test01.Book">
    <property name="bname" value="abc"/>
</bean>

使用有参数构造进行注入

有参数构造可以使用constructor-arg标签指定属性的值

// Book.java
public class Book {
    private String bname;

    public Book(String bname){
        this.bname = bname;
    }
}

<bean id="book" class="com.adrainty.test01.Book">
    <constructor-arg name="bname" value="abc"/>
</bean>

constructor-arg有一个参数是index，当index为0表示有参构造器的第一个参数，为1代表第二个，以此类推

还有一种注入方式是p名称空间注入，严格上属于set方法的一种，但是他可以简化配置

方法：

添加p名称空间在配置文件中

<beans	......
       xmlns:p="http://www.springframework.org/schema/p"
       />

在bean标签内进行属性注入

<bean id="book" class="com.adrainty.test01.Book" p:bname="abc">
    <!--<property name="bname" value="abc"/>-->
</bean>

2.3.2 IOC操作Bean管理（xml注入特殊类型属性）

注入空值和属性值包含特殊符号的情况

<!--null值-->
<property name="bname">
	<null/>
</property>
<!--特殊符号-->
<property name="bauthor" value="&lt;"/>
<property name="bauthor">
    <value><![CDATA[<<112233>>]]></value>
</property>

注入属性-外部bean

方法：

创建两个类 service类和dao类

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

public class UserDaoImpl implements UserDao{
    @Override
    public void update() {
        System.out.println("dao update...");
    }
}

在service调用dao里面的方法

private UserDao userDao;

public void setUserDao(UserDao userDao) {
	this.userDao = userDao;
}

在spring配置文件中进行配置

<bean id="userService" class="com.adrainty.service.UserService">
    <property name="userDao" ref="userDao"/>
</bean>
<bean id="userDao" class="com.adrainty.dao.UserDaoImpl"/>

注入属性-内部bean

一个部门有多个员工，一个员工属于一个部门

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

public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }
}

public class Emp {
    private String ename;
    private String gender;

    private Dept dept;

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
}

<bean id="emp" class="com.adrainty.test01.Emp">
    <property name="ename" value="lucy"/>
    <property name="gender" value="female"/>
    <property name="dept">
        <bean id="dept" class="com.adrainty.test01.Dept">
            <property name="dname" value="baoan0"/>
        </bean>
    </property>
</bean>

注入属性-级联赋值

<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property> 
    <property name="gender" value="female"></property>
    <!--级联赋值--> 
    <property name="dept" ref="dept"></property>
</bean> 
<bean id="dept" class="com.atguigu.spring5.bean.Dept"> 
    <property name="dname" value="money"></property> 
</bean>

2.3.3 IOC操作Bean管理（xml注入集合属性）

注入数组类型属性、List集合类型、Map集合类型：

创建类，定义数组、list、map、set类型属性，生成对应set方法

public class Stu { 
    private String[] courses; 
    private List<String> list; 
    private Map<String,String> maps; 
    private Set<String> sets; 
    
    public void setSets(Set<String> sets) { 
        this.sets = sets; 
    } 
    
    public void setCourses(String[] courses) { 
        this.courses = courses; 
    } 
    
    public void setList(List<String> list) {
        this.list = list; 
    } 
    
    public void setMaps(Map<String, String> maps) {
        this.maps = maps; 
    } 
}

在spring配置文件进行配置

<!--集合类型属性注入-->
<bean id="stu" class="com.adrainty.collectiontype"> 
    <!--数组类型属性注入--> 
    <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> 
</bean>

在集合里面设置对象类型值：

<bean id="course1" class="com.adrainty.collectiontype.Course"> 
    <property name="cname" value="Spring5框架"></property> 
</bean> 
<bean id="course2" class="com.atguigu.adrainty.collectiontype.Course"> 
    <property name="cname" value="MyBatis框架"></property> 
</bean> <!--注入list集合类型，值是对象--> 
<property name="courseList"> 
    <list> 
        <ref bean="course1"></ref>
        <ref bean="course2"></ref> 
    </list> 
</property>

把集合注入部分提取出来

在spring配置文件中引入名称空间 util

<beans ...
       xmlns:util="http://www.springframework.org/schema/util"
       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">

使用util标签完成list集合注入提取

<util:list id="bookList">
    <value>易筋经</value> 
    <value>九阴真经</value> 
    <value>九阳神功</value> 
</util:list> 

<!--2 提取list集合类型属性注入使用--> 
<bean id="book" class="com.adrainty.collectiontype.Book"> 
    <property name="list" ref="bookList"></property>
</bean>

2.3.4 IOC操作Bean管理（工厂Bean）

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

普通bean：在配置文件中定义bean类型就是返回类型
工厂bean：在配置文件定义bean类型可以和返回类型不一样

方法：

创建类，让这个类作为工厂bean，实现接口 FactoryBean
实现接口里面的方法，在实现的方法中定义返回的bean类型

public class MyBean implements FactoryBean<Book> {
    @Override
    public Book getObject() throws Exception {
        Book book = new Book("abc");
        return book;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

<bean id="myBean" class="com.adrainty.factorybean.MyBean"></bean>

2.3.5 IOC操作Bean管理（Bean标签的作用域和生命）

在Spring里面，可以设置创建bean实例是单实例还是多实例，在默认情况下，是单实例对象

在spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例

默认值，singleton，表示是单实例对象
prototype，表示是多实例对象

设置scope值是singleton时候，加载spring配置文件时候便会创建对象

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

bean对象的生命周期：

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

后置处理器需要继承后置处理器的接口BeanPostProcess

2.3.6 IOC操作Bean管理（xml自动装配）

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

bean标签属性autowire，配置自动装配

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

<bean id="dept" class="com.adrainty.autowrite.Dept"/>
<bean id="emp" class="com.adrainty.autowrite.Emp" autowire="byName">
    <!--        <property name="dept" ref="dept"/>-->
</bean>

2.3.7 IOC操作Bean管理(外部属性文件)

1.创建外部属性文件，properties格式文件，写数据库信息

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/test
prop.userName=root
prop.password=root

2.把外部properties属性文件引入到spring配置文件中(引入context名称空间)

3.在spring配置文件使用标签引入外部属性文件

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

    <context:property-placeholder location="classpath:../xml/jdbc.properties"/>
    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverclass}"/>
        <property name="url" value="${prop.url}"/>
        <property name="username" value="${prop.username}"/>
        <property name="password" value="${prop.password}"/>
    </bean>
</beans>

2.3.8 IOC操作Bean管理(基于注解方式)

注解：

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

Spring针对Bean管理中创建对象提供注解：

@Component
@Service
@Controller
@Repository

上面四个注解功能是一样的，都可以用来创建bean实例，一般来说不同层用不同的注解

步骤：

引入依赖spring-aop-5.2.6.RELEASE.jar
开启组件扫描

<!--  开启组件扫描  -->
<!--  如果扫描多个包，可以指定相同的上层目录，或使用逗号隔开  -->
<context:component-scan base-package="com.adrainty.testdemo"/>

<!--  use-default-filters表示不使用默认filter，自己配置filter  -->
<context:component-scan base-package="com.adrainty.springmvc" use-default-filters="false">
    <!--  include-filter设置扫描哪些内容  -->
	<context:include-filter type="annotation"
           expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<context:component-scan base-package="com.adrainty.springmvc">
    <!--  exclude-filter设置不扫描哪些内容  -->
	<context:exclude-filter type="annotation"
        	expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

创建类，在类上面添加注解

// value属性值可以省略不写，默认是类名称，首字母小写
@Component(value = "userService")
public class UserService {
    public void add(){
        System.out.println("add....");
    }
}

基于注解方式实现属性注入

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

@Service 
public class UserService {
    //添加注入属性注解 
    @Autowired 
    private UserDao userDao; 
    
    public void add() {
        System.out.println("service add.......");
        userDao.add(); 
    } 
}

@Qualifier：根据名称进行注入

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

该注解和一般@Autowired一起使用

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

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

Resource不是spring的包，是javax的包

@Value：注入普通类型属性

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

完全注解开发

其实我们在xml中只配置了一行代码，即开启组件扫描

我们可以生成配置类SpringConfig.java做到不需要xml，完全采用注解开发

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

在测试类中改为

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

这种情况在SpringBoot比较常见，SpringBoot本质上其实是Spring的一种，只是做了高度集成而已

3 AOP

3.1 概念和底层原理

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

不通过修改源代码方式，在主干功能里面添加新功能

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

有接口情况，使用JDK动态代理

创建接口实现类的代理对象，增强类的方法

没有接口情况，使用CGLIB动态代理

创建子类的代理对象，增强类的方法

AOP的一些术语

连接点：类里面哪些方法可以被增强，这些方法称为链接点
切入点：实际被真正增强的方法，称为切入点
通知（增强）：实际增强的逻辑部分称为通知（增强），通知有多种类型
- 前置通知：在方法的前面增强Before
- 后置通知：在方法的后面增强After
- 环绕通知：在方法前后都增强Around
- 异常通知：当方法出现了异常会执行AfterThrowing
- 最终通知：无论方法是否出现异常都会执行AfterReturning
切面：把通知应用到切入点的过程

环绕通知被增强的方法执行采用proceedingJoinPoint.proceed()

3.2 JDK 动态代理

使用JDK动态代理，使用Proxy类里面的方法创建代理对象

loader：类加载器
interfaces：增强方法所在的类，这个类实现的接口，支持多个接口
h：实现这个接口InvocationHandler，创建代理对象，写增强的部分

使用：

创建接口，定义方法

public interface UserDao {
    public int add(int a, int b);
}

创建接口实现类，实现方法

public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

使用Proxy类创建接口代理对象

public class JDKProxy {
    public static void main(String[] args) {
        //
        Class[] interfaces = {UserDao.class};
        UserDao userDao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
            final UserDaoImpl userDao = new UserDaoImpl();

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("方法前");
                Object invoke = method.invoke(userDao, args);
                System.out.println("方法后");
                return invoke;
            }
        });
        int result = userDao.add(1, 2);
        System.out.println(result);
    }
}

3.3 AOP操作概述

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

需要引入依赖：

com.springsource.net.sf.cglib-2.2.03.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
spring-aspects-5.2.6.RELEASE.jar

切入点表达式：知道对哪个类里面的哪个方法进行增强

execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )

返回类型可省略，权限修饰符若不做要求可以用*代替

3.4 AspectJ 注解

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

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

创建增强类（编写增强逻辑）

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

进行通知的配置

在spring配置文件中，开启注解扫描，在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: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/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 base-package="com.adrainty.aopanoo"/>
	<!-- 开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy/>

</beans>

使用注解创建User和UserProxy对象，在增强类上面添加注解 @Aspect

@Component
public class User

// 在增强类上面添加注解 @Aspect
@Component
@Aspect
public class UserProxy

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

@Component 
@Aspect //生成代理对象 
public class UserProxy {
    //前置通知 
    @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))") 
    public void before() { 
        System.out.println("before........."); 
    } 
    
    //后置通知（返回通知） 
    @AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))") 
    public void afterReturning() { System.out.println("afterReturning........."); 
                                 } 
    
    //最终通知 
    @After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))") 
    public void after() { System.out.println("after........."); 
                        } 
    //异常通知 
    @AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))") 
    public void afterThrowing() { System.out.println("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("环绕之后........."); 
    } 
}

相同的切入点抽取

@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))") public void pointdemo() { } @Before(value = "pointdemo()") public void before() { System.out.println("before........."); }

有多个增强类多同一个方法进行增强，设置增强类优先级

在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高

4 JdbcTemplate

4.1 概念和准备

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

引入相关jar包

spring-orm-5.2.6.RELEASE.jar

spring-tx-5.2.6.RELEASE.jar

spring-jdbc-5.2.6.RELEASE.jar

2.配置德鲁伊连接池

<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>

配置JdbcTemplate对象，注入DataSource

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

4.2 JdbcTemplate操作数据库

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

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

@Repository 
public class BookDaoImpl implements BookDao {
    //注入JdbcTemplate 
    @Autowired 
    private JdbcTemplate jdbcTemplate; 
}

4.2.1 添加操作

@Override
public void addBook(Book book) {
    String sql = "insert into t_book values(?, ?, ?)";
    int update = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUserStatus());
    System.out.println(update);
}

遇到的坑如下：

Unknown initial character set index '255' received from server.

需要在链接后加入?useUnicode=true&characterEncoding=utf8

Unescaped & or nonterminated character/entity reference

&改写成&

Client does not support authentication protocol requested by server; consider upgrading MySQL client

mysql8 之前的版本中加密规则是mysql_native_password,而在mysql8之后,加密规则是caching_sha2_password

输入命令修改加密规则

ALTER USER 'root'@'localhost' IDENTIFIED BY 'root' PASSWORD EXPIRE NEVER; ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'root'; FLUSH PRIVILEGES;

4.2.2 修改操作

@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); 
}

4.2.3 删除操作

@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); 
}

4.2.4 查询返回某个值

@Override 
public int selectCount() {
    String sql = "select count(*) from t_book"; 
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    return count; 
}

4.2.5 查询返回对象

@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; 
}

4.2.6 查询返回集合

@Override 
public List<Book> findAllBook() {
    String sql = "select * from t_book"; 
    //调用方法
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class)); 
    return bookList; 
}

4.3 事务操作

事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败

事务四个特性（ACID）

原子性
一致性
隔离性
持久性

Spring进行事务管理操作有两种方式：编程式事务管理和声明式事务管理

声明式事务管理，底层使用AOP原理，既可以使用注解方式，也可以使用配置文件方式

Spring事务管理API提供一个接口(PlatformTransactionManager)，代表事务管理器，这个接口针对不同的框架提供不同的实现类

4.3.1 注解声明式事务管理

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

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
    <!--注入数据源--> 
    <property name="dataSource" ref="dataSource"/>
</bean>

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

在spring配置文件引入名称空间 tx
开启事务注解

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

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

@Transactional
public class UserService

4.3.2 声明式事务管理参数配置

propagation：事务传播行为

Spring框架事务传播行为有7种

传播属性	描述
REQUIRED	如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行
REQUIRED_NEW	当前的方法必须启动新事物，并在它自己的事务内运行，如果有事务正在运行，应该将它挂起
SUPPORTS	如果有事务在运行，当前的方法就在这个事务内运行，否则它可以不运行在事务中
NOT_SUPPORTED	当前的方法不应该运行在事务中，如果有运行的事务，将它挂起
MANDATOR	当前的方法必须运行在事务内部，如果没有正在运行的事务，就抛出异常
NEVER	当前的方法不应该运行在事务中，如果有运行的事务，就抛出异常
NESTED	如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则，就启动一个新的事务，并在它自己的事务内运行

@Transactional(propagation = Progagation.REQUIRED)

ioslation：事务隔离级别

事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题

有三个读问题：脏读、不可重复读、虚（幻）读

脏读：一个未提交事务读取到另一个未提交事务的数据
虚读：一个未提交事务读取到另一提交事务添加数据
不可重复读：一个未提交事务读取到另一提交事务修改数据

名称	解释	脏读	不可重复读	幻读
READ_UNCOMMITTED	读未提交	有	有	有
READ_COMMITTED	读已提交	无	有	有
REPEATABLE_READ	可重复读	无	无	有
SERIALIZABLE	串行化	无	无	无

@Transactional(propagation = Progagation.REQUIRED, isolation=Isolation.REPEATABLE_READ)

timeout：超时时间

事务需要在一定时间内进行提交，如果不提交进行回滚>默认值是 -1 ，设置时间以秒单位进行计算

readOnly：是否只读

readOnly默认值false，表示可以查询，可以添加修改删除操作，设置成true之后，只能查询

rollbackFor：回滚

设置出现哪些异常进行事务回滚

noRollbackFor：不回滚

设置出现哪些异常不进行事务回滚

4.3.3 完全注解声明式事务管理

@Configuration //配置类 
@ComponentScan(basePackages = "com.adrainty") //组件扫描 @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; 
    } 
}

5 Spring5新特性

5.1 整合日志框架

Spring5已经移除Log4jConfigListener，官方建议使用Log4j2

引入jar包

log4j-api-2.11.2.jar

log4j-core-2.11.2.jar

log4j-slf4j-impl-2.11.2.jar

slf4j-api-1.7.30.jar

**创建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>

5.2 支持@Nullable注解

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

5.3 支持函数式风格

GenericApplicationContext对象

//函数式风格创建对象，交给spring进行管理 
@Test 
public void testGenericApplicationContext() {
    //1 创建GenericApplicationContext对象 
    GenericApplicationContext context = new GenericApplicationContext();
    //2 调用context的方法对象注册 
    context.refresh(); 
    context.registerBean("user1",User.class,() -> new User()); 
    //3 获取在spring注册的对象 
    // User user = (User)context.getBean("com.adrainty.spring5.test.User"); 
    User user = (User)context.getBean("user1"); 
    System.out.println(user); 
}

5.4 支持整合JUnit5

5.4.1 整合JUnit4

@RunWith(SpringJUnit4ClassRunner.class) //单元测试框架 @ContextConfiguration("classpath:bean1.xml") //加载配置文件
public class JTest4 {
    @Autowired 
    private UserService userService; 
    
    @Test 
    public void test1() {
        userService.accountMoney(); 
    } 
}

5.4.2 整合JUnit5

创建测试类，使用注解完成

@ExtendWith(SpringExtension.class) @ContextConfiguration("classpath:bean1.xml") 
public class JTest5 {
    @Autowired 
    private UserService userService; 
    
    @Test 
    public void test1() {
        userService.accountMoney(); 
    } 
}

使用一个复合注解替代上面两个注解完成整合

@SpringJUnitConfig(locations = "classpath:bean1.xml") 
public class JTest5 { 
    @Autowired 
    private UserService userService; 
    
    @Test 
    public void test1() {
        userService.accountMoney(); 
    } 
}