Spring5笔记

一、Spring框架概述

1、Spring是一个轻量级的开源JavaEE框架

2、Spring可以解决企业应用开发的复杂性

3、Spring有两个核心部分：IOC和AOP

（1）IOC：控制反转，把创建对象过程交给Spring进行管理

（2）AOP：面向切面，不修改源代码进行功能增强

4、Spring特点

（1）方便解耦，简化开发

（2）AOP编程支持

（3）方便程序测试

（4）方便和其他框架进行整合

（5）方便进行事务操作

（6）降低了API的开发难度

二、IOC

1、什么是IOC

（1）控制反转(Inversion of Control)：把对象的创建和对象之间的调用过程，交给Spring进行管理

（2）目的：降低耦合度

2、IOC底层原理

（1）xml解析（2）工厂模式（3）反射

3、IOC过程

4、IOC接口

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

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

• BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用

​ 特点：加载配置文件时不创建对象，在获取（使用）对象的时候才创建

• ApplicationContext：BeanFactory接口的子接口，提供更强大的功能，一般由开发人员进行使用

​ 特点：加载配置文件的时候就会创建配置文件中的对象

（3）ApplicationContext接口有实现类

• ClassPathXmlApplicationContext：通过src下类路径获取资源

• FileSystemXmlApplicationContext：通过盘符全路径获取资源

5、IOC操作Bean管理

（1）什么是Bean管理

Bean管理指两个操作

• Spring创建对象
• Spring注入属性

（2）Bean管理的操作方式

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

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

6.1、基于xml方式创建对象

• 在Spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
• 在bean标签中有很多属性，介绍常用属性
  • id：唯一标识一个类
  • class：类全路径（包类路径）
• 创建对象的时候，默认执行无参构造方法完成对象创建

6.2、基于xml方式注入属性

​ 1、DI：依赖注入，就是注入属性，DI是IOC的一种具体实现，需要在创建对象的基础上完成

​ 2、注入方式：

6.2.1使用set方法进行注入

①创建类，定义属性和对应的set方法

public class User {
    private String name;
    public int age;

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

    public void setAge(int age) {
        this.age = age;
    }
}

②在Spring配置文件配置对象创建，配置属性注入

<bean id="user" class="com.wjx.spring.User">
        <property name="name" value="wjx"></property>
        <property name="age" value="20"></property>
</bean>

6.2.2使用有参数构造进行注入

①创建类，定义属性，创建属性对应有参数构造方法

public class User {
    private String name;
    public int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

②在Spring配置文件中进行配置

<bean id="user1" class="com.wjx.spring.User">
        <constructor-arg name="name" value="ljy"></constructor-arg>
        <constructor-arg name="age" value="20"></constructor-arg>
</bean>

7、IOC操作Bean管理（xml注入其他类型属性）

7.1、字面量

（1）设置属性为null值

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

（2）属性值包含特殊符号

<property name="add">
    <value>
        <![CDATA[
                <<重庆>>                
                ]]>
    </value>
</property>

7.2、注入属性——外部bean

（1）创建service类、dao类、dao实现类daoImpl

UserDAO

public interface UserDao {
    public void add();
}

UserDaoImpl

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

UserService

public class UserService {
    private UserDao userDao;

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

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

    }
}

（2）在service调dao的方法

（3）在Spring配置文件中配置

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

7.3、注入属性——内部bean

（1）一对多关系；eg.部门和员工

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

部门类

public class Dept {
    private String deptName;

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }
}

员工类

public class Emp {
    private String name;
    private int age;
    private Dept dept;

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

    public void setAge(int age) {
        this.age = age;
    }

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

（3）在Spring配置文件中进行配置

<bean id="Emp" class="com.wjx.spring.pojo.Emp">
    <property name="name" value="吴俊贤"></property>
    <property name="age" value="20"></property>
    <property name="Dept">
        <bean id="Dept" class="com.wjx.spring.pojo.Dept">
            <property name="deptName" value="后端开发"></property>
        </bean>
    </property>
</bean>

7.4、注入属性——级联赋值

（1）方式一

<bean id="Emp1" class="com.wjx.spring.pojo.Emp">
    <property name="name" value="李嘉仪"></property>
    <property name="age" value="20"></property>
    <property name="dept" ref="Dept1"></property>
</bean>
<bean id="Dept1" class="com.wjx.spring.pojo.Dept">
    <property name="deptName" value="算法设计"></property>
</bean>

（2）方式二

<bean id="Emp2" class="com.wjx.spring.pojo.Emp">
    <property name="name" value="李饺饺"></property>
    <property name="age" value="3"></property>
    <property name="dept" ref="Dept2"></property>
    <property name="dept.deptName" value="前端开发"></property>
</bean>
<bean id="Dept2" class="com.wjx.spring.pojo.Dept"></bean>

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

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

（1）创建类，定义数组、List、Map、Set类型属性，生成对应的set方法

public class CollectionTypes {
    private String[] student;
    private List<String> courses;
    private Map<String,Integer> grades;
    private Set<String> addres;

    public void setStudent(String[] student) {
        this.student = student;
    }

    public void setCourses(List<String> courses) {
        this.courses = courses;
    }

    public void setGrades(Map<String, Integer> grades) {
        this.grades = grades;
    }

    public void setAddres(Set<String> addres) {
        this.addres = addres;
    }

    @Override
    public String toString() {
        return "CollectionTypes{" +
                "student=" + Arrays.toString(student) +
                ", courses=" + courses +
                ", grades=" + grades +
                ", addres=" + addres +
                '}';
    }
}

（2）在Spring配置文件中配置

<bean id="student" class="com.wjx.spring.collections.CollectionTypes">
    <!--数组
    <property name="student">
        <array>
            <value>吴俊贤</value>
            <value>李嘉仪</value>
        </array>
    </property>
    <!--List-->
    <property name="courses">
        <list>
            <value>java</value>
            <value>C语言</value>
        </list>
    </property>
    <!--Map-->
    <property name="grades">
        <map>
            <entry key="java" value="90"></entry>
            <entry key="C语言" value="100"></entry>
        </map>
    </property>
    <!--set-->
    <property name="addres">
        <set>
            <value>无</value>
        </set>
    </property>
</bean>

8.2、在集合里面设置对象类型的值

<bean id="student" class="com.wjx.spring.collections.Student">
    <property name="name">
        <array>
            <value>吴俊贤</value>
            <value>李嘉仪</value>
        </array>
    </property>
    <property name="courses">
        <list>
            <ref bean="course"></ref>
            <ref bean="course1"></ref>
        </list>
    </property>
</bean>
<bean id="course" class="com.wjx.spring.collections.Course">
    <property name="name" value="数据库"></property>
</bean>
<bean id="course1" class="com.wjx.spring.collections.Course">
    <property name="name" value="算法设计"></property>
</bean>

8.3、提取中集合中的公共部分

（1）在Spring配置文件中引入名称空间 util

<?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: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">
</beans>

（2）使用util标签完成List注入

<util:list id="userList">
    <value>吴俊贤</value>
    <value>李嘉仪</value>
</util:list>

<bean id="bookUsers" class="com.wjx.spring.collections.Book">
    <property name="username" ref="userList"></property>
</bean>

9、IOC操作Bean管理（FactoryBean）

Spring有两种类型的bean：

• 普通bean

  在配置文件中定义bean类型就是返回类型

• 工厂bean

  在配置文件中定义bean类型可以和返回类型不一样

（1）创建类，让这个类作为工厂bean，实现接口FactoryBean

public class MyBean implements FactoryBean<Course>{
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setName("操作系统");
        return course;
    }

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

    @Override
    public boolean isSingleton() {
        return false;
    }
}

（2）实现接口里面的方法，在实现的方法中定义返回的bean类型

<bean id="myBean" class="com.wjx.spring.collections.MyBean">

</bean>

10、IOC操作Bean管理（bean的作用域）

1、Spring中，默认情况下创建的bean是单实例对象

2、Spring中，如何设置单实例还是多实例

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

（2）scope属性值

• singleton（默认值），单实例
• prototype，多实例
• request，一次请求
• session，一次会话

3、singleton和prototype的区别

（1）singleton单实例，prototype多实例

（2）

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

​

11、IOC操作Bean管理（bean的生命周期）

1、生命周期

​ 从对象创建到对象销毁的过程

2、bean生命周期（5步）

（1）通过构造器创建bean实例（无参数构造）

（2）为bean的属性设置值和其他bean引用（调用set方法）

（3）调用bean的初始化方法（需要进行配置初始化方法）

（4）bean使用（获取到了对象）

（5）当容器关闭时，调用bean的销毁的方法（需要进行配置销毁的方法）

3、bean生命周期过程

public class Flower {
    private String name;
		
    public Flower() {
        System.out.println("1、无参构造方法创建对象");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("2、调用set方法注入属性");
    }

    //配置文件中配置init-method
    public void initMethod() {
        System.out.println("3、初始化对象");
    }
	//配置文件中配置destroy-method
    public void destroyMethod() {
        System.out.println("5、对象被销毁了");
    }
}

<bean id="flower" class="com.wjx.spring.lifecycle.Flower" init-method="initMethod" destroy-method="destroyMethod">
    <property name="name" value="泡泡玫瑰"></property>
</bean>

4、配置了后置处理器后的bean生命周期 （7步）

（1）通过构造器创建bean实例（无参数构造）

（2）为bean的属性设置值和其他bean引用（调用set方法）

（3）将bean实例传递给bean的before后置处理器方法

（4）调用bean的初始化方法（需要进行配置初始化方法）

（5）将bean实例传递给bean的after后置处理器方法

（6）bean使用（获取到了对象）

（7）当容器关闭时，调用bean的销毁的方法（需要进行配置销毁的方法）

5、配置后置处理器

（1）创建类，实现BeanPostProcessor()方法

public class beanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("3、调用初始化之前执行的方法");
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("5、调用初始化之后执行的方法");
        return null;
    }
}

（2）配置文件中配置后置处理器

<bean id="flower" class="com.wjx.spring.lifecycle.Flower" init-method="initMethod" destroy-method="destroyMethod">
    <property name="name" value="泡泡玫瑰"></property>
</bean>

<!--配置后置处理器-->
<bean id="beanPost" class="com.wjx.spring.lifecycle.beanPost"></bean>

（3）后置处理器为当前配置文件中的所有bean实例配置后置处理器

---

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

1、什么是自动装配

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

2、自动装配方式

（1）根据属性名自动注入

配置文件中bean标签添加autowire="byName"

（2）根据属性类型自动注入

autowire=“byType”

---

13、IOC操作Bean管理（外部属性文件）

1、直接配置数据库连接池

​ 配置Druid连接池

2、引入外部属性文件配置数据库连接池

（1）创建外部配置文件jdbc.properties

prop.driverClassName=com.mysql.cj.jdbc.driver
prop.url=jdbc:mysql://localhost:3306/test
prop.username=root
prop.password=wjx123++

（2）把外部properties属性文件引入到spring配置文件中

• 引入名称空间context

<?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"
       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">
</beans>

• 引入外部属性文件

<context:property-placeholder location="classpath:jdbc.properties"/>

• bean实例${}表达式取值

<bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${prop.driverClassName}"></property>
    <property name="url" value="${prop.url}"></property>
    <property name="username" value="${prop.username}"></property>
    <property name="password" value="${prop.password}"></property>
</bean>

---

14、IOC操作Bean管理（基于注解方式）

1、什么是注解

• 注解是代码特殊标记

  格式：@注解名称（属性名称=属性值，属性名称=属性值…）

• 注解可作用在类、方法、属性上面

• 使用注解的目的：简化xml配置

2、Spring针对Bean管理中创建对象提供的注解

• @Component
• @Service
• @Controller
• @Repository

上面四个注解功能是一样的，都可用来创建bean实例

3、基于注解方法实现对象创建

（1）开启组件扫描

• 引入名称空间context

<?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"
       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">
</beans>

• 配置组件扫描

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

（2）创建类，在类上面添加创建对象注解

• @…(value=…)
• 不写value，默认值是类名且首字母小写

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

（3）getBean()

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();

4、组件扫描细节问题

use-default-filters=true（默认），使用默认过滤器，扫描所有

• 扫描指定注解

<context:component-scan base-package="com.wjx.spring" use-default-filters="false">
    <context:include-filter type="annotation"
                            expression="org.springframework.stereotype.Service"/>
</context:component-scan>

• 不扫描指定注解

<context:component-scan base-package="com.wjx.spring">
    <context:exclude-filter type="annotation"
                            expression="org.springframework.stereotype.Service"/>
</context:component-scan>

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

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

• @Qualifier：根据属性名称进行注入

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

• @Value：注入普通类型(int、String…)属性

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

@Repository
public class UserDaoImpl1 implements UserDao{
    @Override
    public void add() {
        System.out.println("UserDao add2...");
    }
}

@Service
public class UserService {
    @Value(value = "test")
    private String name;
    @Autowired //根据类型注入
    @Qualifier(value = "userDaoImpl1")  //根据名字注入
//    @Resource //根据类型注入
//    @Resource(value="userDaoImpl") //根据名字注入
    private UserDao userDao;

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

15、IOC操作Bean管理（完全注解开发）

（1）、创建配置类，代替xml

• @Configuration
• @ComponentScan(basePackages="…")

@Configuration
@ComponentScan(basePackages = "com.wjx.spring")
public class SpringConfig {
}

（2）、创建对象

• new 注解配置类对象
• getBean

@Test
public void test2() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    System.out.println(userService);
    userService.add();
}

---

三、AOP

1、什么是AOP

1、面向切面编程

​ 通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2、通俗描述：不通过修改源代码，在主干功能中添加新功能

---

2、AOP底层原理

AOP底层使用动态代理

1、两种动态代理情况

第一种：有接口，使用JDK动态代理

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

第二种：无接口，使用CGLIB动态代理

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

---

3、AOP（JDK动态代理）

1、JDK动态代理使用Proxy类中的方法创建出代理对象

• 参数一：类加载器
• 参数二：增强方法所在的类，这个类实现的接口，支持多接口
• 参数三：实现这个接口InvocationHandler，创建代理对象，写增强的部分

2、编写JDK动态代理代码

（1）创建接口，定义方法

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

    public void update();
}

（2）创建类，实现接口

public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        System.out.println("add方法被执行了...");
        return a+b;
    }

    @Override
    public void update() {
        System.out.println("update方法被执行了...");
    }
}

（3）使用Proxy类创捷接口对象

/*实现动态代理，增强UserDao中所有方法功能*/
public class JDKProxy {
    public static void main(String[] args) {
        UserDaoImpl userDao = new UserDaoImpl();
        Class[] interfaces = {UserDao.class};
        /*创建增强功能的代理对象*/
        UserDao proxyInstance = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new methodBoost(userDao));
        proxyInstance.add(1, 2);
        proxyInstance.update();
    }
}

/*编写代理对象调用的增强方法*/
class methodBoost implements InvocationHandler{
    private Object obj;

    /*有参构造函数接收被代理对象*/
    public methodBoost(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /*执行方法之前*/
        System.out.println("方法执行之前..." + "method="+method.getName() + " "+"arg=" + Arrays.toString(args));

        /*执行原方法*/
        Object invoke = method.invoke(obj, args);

        /*执行方法之后*/
        System.out.println("方法执行之后...方法执行结果:" + invoke);

        return invoke;
    }
}

4、AOP（操作术语）

1、连接点

可以被增强的方法被称为连接点

2、切点

实际被增强的方法被称为切点

3、增强（通知）

（1）实际增强的逻辑部分被称为增强（通知）

（2）通知有多种类型

• 前置通知
• 后置通知
• 环绕通知
• 异常通知
• 最终通知

4、切面

是一个动作，是把通知应用到切入点的过程

eg.登录过程中增加一个权限判断

---

5、AOP操作（准备）

1、Spring框架一般是基于AspectJ框架实现AOP操作

2、基于AspectJ实现AOP操作

（1）基于xml配置文件实现

（2）基于注解方式实现

3、引入相关依赖

4、切入点表达式

（1）作用：明确对哪个类哪个方法进行增强

（2）语法结构：

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

eg1.对com.wjx.dao.UserDao类中的add方法进行增强

execution(* com.wjx.dao.UserDao.add(…))

*为返回类型

eg2.对com.wjx.dao.UserDao类中所有方法进行增强

execution(* com.wjx.dao.UserDao.*(…))

eg3.对com.wjx.dao中所有类中所有方法进行增强

execution(* com.wjx.dao.*.*(…))

---

6、AOP操作（AspectJ注解）

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

2、创建增强类，编写增强逻辑

增强类中，创建不同方法代表不同增强

3、配置增强

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

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

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

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

4、配置不同类型的通知

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

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

@Component
@Aspect
public class proxy {

    /*前置通知*/
    @Before("execution(* com.wjx.spring.aopAnno.User.add(..))")
    public void before() {
        System.out.println("before...");
    }
    /*后置(返回)通知*/
    @After("execution(* com.wjx.spring.aopAnno.User.add(..))")
    public void after() {
        System.out.println("after...");
    }
    /*异常通知*/
    @AfterThrowing("execution(* com.wjx.spring.aopAnno.User.add(..))")
    public void afterThrow() {
        System.out.println("afterThrow...");
    }
    /*最终通知*/
    @AfterReturning("execution(* com.wjx.spring.aopAnno.User.add(..))")
    public void afterReturn() {
        System.out.println("afterReturn...");
    }
    /*环绕通知*/
    @Around("execution(* com.wjx.spring.aopAnno.User.add(..))")
    private void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
 		/*执行方法前执行*/       
        System.out.println("beforeAround...");
 		/*执行被增强的方法*/       
        proceedingJoinPoint.proceed();
 		/*执行方法之后执行*/       
        System.out.println("afterAround...");
    }
}

<?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 base-package="com.wjx.spring.aopAnno"></context:component-scan>
    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

5、抽取相同的切入点

/*抽取切入点*/
@Pointcut("execution(* com.wjx.spring.aopAnno.User.add(..))")
public void pointcut() {

}

/*前置通知*/
@Before("pointcut()")
public void before() {
    System.out.println("before...");
}

6、设置多个增强类的优先级

增强类上添加**@Order**（整型）注解，数字值越小优先级越高

@Component
@Aspect
@Order(1)
public class proxy2 {
    @Before("execution(* com.wjx.spring.aopAnno.User.add(..))")
    public void before() {
        System.out.println("before1...");
    }
}

7、AOP操作（AspectJ配置文件）

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

public class Book {
    public void buy() {
        System.out.println("buy...");
    }
}

public class proxy {
    public void before() {
        System.out.println("before...");
    }
}

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

<!--配置被增强类和增强类-->
<bean id="book" class="com.wjx.spring.aopxml.Book"></bean>
<bean id="proxy" class="com.wjx.spring.aopxml.proxy"></bean>

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

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

---

8、AOP操作（完全注解开发）

（1）创建配置类，不需要创建xml配置文件

@Configuration
@ComponentScan(basePackages = "com.wjx.spring.aopAnno")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class aopconfig {
}

（2）创建对象

• new 注解配置类对象
• getBean

public void test() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(aopconfig.class);
    User user = context.getBean("user", User.class);
    user.add();
}

四、JDBCTemplate

1、什么是JDBCTeplate

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

2、准备工作

（1）引入依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
</dependency>

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.16</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-orm -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>

（2）在Spring配置文件配置数据库连接池

<!--配置数据库连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="url" value="jdbc:mysql:///test"/>
    <property name="username" value="root"/>
    <property name="password" value="wjx123++"/>
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
</bean>

（3）配置JdbcTemplate对象，注入DataSource

<!--配置jdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--set方法注入dataSource-->
    <property name="dataSource" ref="dataSource"/>
</bean>

（4）创建service、dao类，在dao注入jdbcTemplate

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

@Service
public class bookService {
    @Autowired
    private BookDao bookDao;
}

3、JdbcTemplate操作数据（添加）

public interface BookDao {
    void add(Book book);
}

@Repository
public class BookDaoImpl implements BookDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(Book book) {
        String sql = "insert into bookList values(?,?)";
        Object[] args = {book.getbName(), book.getbPrice()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println("成功插入了"+update+"条数据");
    }
}

@Service
public class bookService {
    @Autowired
    private BookDao bookDao;

    public void addBook(Book book) {
        bookDao.add(book);
    }
}

public void test() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    bookService bookService = context.getBean("bookService", bookService.class);
    Book book = new Book("java", 20);
    bookService.addBook(book);
}

4、JdbcTemplate操作数据（修改和删除）

BookDaoImpl
/*更新*/
@Override
public void update(Book book,String newName,int newPrice) {
    String sql = "update bookList set bName=?,bPrice=? where bName=?";
    Object[] args = {newName, newPrice,book.getbName()};
    int update = jdbcTemplate.update(sql, args);
    System.out.println("成功更新了"+update+"条数据");
}
/*删除*/
@Override
public void delete(Book book) {
    String sql = "delete from bookList where bName=?";
    Object[] args = {book.getbName()};
    jdbcTemplate.update(sql, args);
    System.out.println("删除成功");
}

5、JdbcTemplate操作数据（查询）

1、查询某个值

• 参数1：sql语句
• 参数2：返回类型的Class

String sql = "select count(*) from bookList";
Integer count=jdbcTemplate.queryForObject(sql,Integer.class);

2、查询返回对象

• 参数1：sql语句
• 参数2：RowMapper，是一个接口，返回不同类型的数据，使用接口的实现类完成数据封装
• 参数3：sql语句值

String sql = "select * from book where bName=?";
Book book = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Book>(Book.Class),bName);
return book;

3、查询返回对象集合

String sql = "select * from book";
List<Book> bookList = jdbcTemplate.query(sql,new BeanPropertyRowMapper<Book>(Book.Class));
return bookList;

6、JdbcTemplate操作数据（批量操作）

​ 操作表中的多条记录

---

五、事务

1、什么是事务

• 事务时数据库操作最基本单元，逻辑上一组操作，要么都成功，要么都失败。

• 典型场景：银行转账

  lucy转账100给mary

  lucy少100，mary多100

2、事务四个特性（ACID）

• 原子性：一个事务的所有操作，要么全部完成，要么全部不完成。发生错误，回滚到事务开始前的状态，像从来没执行一样
• 一致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏
• 隔离性：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致
• 持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失

3、事务操作（搭建操作环境）

1、创建数据库、表，添加记录

2、创建Service,搭建dao，完成对象创建和注入关系

• Service注入dao，dao注入jdbcTemplate,在jdbcTemplate注入dataSource

public interface UserDao {
    void addMoney(int id, int money);

    void reduceMoney(int id, int money);
}

@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void addMoney(int id, int money) {
        String sql = "update user set money=money+? where id=?";
        Object[] args = {money,id};
        int update = jdbcTemplate.update(sql, args);
        if (update > 0) {
            System.out.println("增加成功！");
        }
    }

    @Override
    public void reduceMoney(int id, int money) {
        String sql = "update user set money=money-? where id=?";
        Object[] args = {money,id};
        int update = jdbcTemplate.update(sql, args);
        if (update > 0) {
            System.out.println("减少成功！");
        }
    }
}

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    public void trade(int adder, int reducer, int money) {
        userDao.reduceMoney(reducer, money);
        userDao.addMoney(adder, money);
    }
}

3、若执行过程发生异常

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    public void trade(int adder, int reducer, int money) {
        userDao.reduceMoney(reducer, money);
        userDao.addMoney(adder, money);
    }
}

使用事务解决

事务操作过程

public void trade(int adder, int reducer, int money) {
    try {
        /*1、开启事务*/

        /*2、进行业务操作*/
        userDao.reduceMoney(reducer, money);
        /*模拟异常*/
        int i = 10 / 0;
        userDao.addMoney(adder, money);
        /*3、没有发生异常，提交事务*/
    } catch (Exception e) {
        /*4、发生异常，事务回滚*/
    }
}

---

4、事务操作（Spring事务管理）

1、事务应该添加到Service层

2、在Spring中进行事务操作

• 两种方式：编程式事务管理和声明式事务管理（使用）

3、声明式事务管理

（1）基于注解方式（使用）

（2）基于xml配置文件方式

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

5、Spring事务管理API

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

5、事务操作（注解声明式事务管理）

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

<!--创建事务管理器-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

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

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

（2）开启事务注解

<tx:annotation-driven transaction-manager="dataSourceTransactionManager"></tx:annotation-driven>

3、在Service类上面(或Service类的方法上面)添加事务注解

• @Transactional，这个注解添加到类上面，也可以添加到方法上面
• 如果添加到类上面，类中所有方法都添加事务
• 如果添加到方法上上面，仅为该方法添加事务

@Service
@Transactional
public class UserService {
    @Autowired
    private UserDao userDao;

    public void trade(int adder, int reducer, int money) {
//        try {
            /*1、开启事务*/

            /*2、进行业务操作*/
            userDao.reduceMoney(reducer, money);
            /*模拟异常*/
            int i = 10 / 0;
            userDao.addMoney(adder, money);
            /*3、没有发生异常，提交事务*/
//        } catch (Exception e) {
            /*4、发生异常，事务回滚*/
//        }
    }
}

6、事务操作（声明式事务管理参数配置）

1、在Service类上面添加注解@Transactional，在这个注解里可以配置事务相关参数

• propagation：事务传播行为

事务的传播行为，默认值为 Propagation.REQUIRED。可以手动指定其他的事务传播行为，如下：
（1）Propagation.REQUIRED

如果当前存在事务，则加入该事务，如果当前不存在事务，则创建一个新的事务。

（2)Propagation.SUPPORTS

如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务的方式继续运行。
（3）Propagation.MANDATORY

如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常。
（4）Propagation.REQUIRES_NEW

重新创建一个新的事务，如果当前存在事务，挂起当前的事务。

（5)Propagation.NOT_SUPPORTED

以非事务的方式运行，如果当前存在事务，暂停当前的事务。

（6)Propagation.NEVER

以非事务的方式运行，如果当前存在事务，则抛出异常。
（7）Propagation.NESTED

如果没有，就新建一个事务；如果有，就在当前事务中嵌套其他事务。

---

• isolation：事务隔离级别

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

---

• timeout：超时时间

（1）事务需要在一定时间内进行提交，如果不提交进行回滚

（2）默认值是-1，设置时间以秒为单位进行计算

---

• readOnly：是否只读

默认值为false，可以查询，可以修改

---

• rollbackFor：回滚

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

---

• noRollbackFor:不回滚

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

---

7、事务操作（xml声明式事务管理）

1、在Spring配置文件中进行配置

（1）配置事务管理器

<!--1、创建事务管理器-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

（2）配置通知

<!--2、配置通知-->
<tx:advice id="txadvice" transaction-manager="dataSourceTransactionManager">
    <tx:attributes>
        <tx:method name="trade" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

（3）配置切入点和切面

<!--3、配置切入点和切面-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="pt" expression="execution(* com.wjx.spring.service.UserService.*(..))"/>
    <!--切面-->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

8、事务操作（完全注解声明式事务管理）

@Configuration //配置类
@ComponentScan(basePackages = "com.wjx.spring")//组件扫描
@EnableTransactionManagement//开启事务
public class txConfiguration {
    /*配置连接池*/
    @Bean
    public DruidDataSource getDruidDataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("wjx123++");
        druidDataSource.setUrl("jdbc:mysql:///banktest");
        return druidDataSource;
    }

    /*创建jdbcTemplate对象*/
    @Bean
    public JdbcTemplate getJdbcTemplate(DruidDataSource druidDataSource) {
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(druidDataSource);
        return jdbcTemplate;
    }

    /*创建事务管理器*/
    @Bean
    public DataSourceTransactionManager dataSourceTransactionManager(DruidDataSource druidDataSource) {
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(druidDataSource);
        return dataSourceTransactionManager;
    }
}