spring5框架核心内容

spring5框架

spring框架概述

1. Spring是轻量级的开源的JavaEE框架
2. Spring可以解决企业应用开发的复杂性
3. Spring有两个核心部分：IOC和AOP
   1. 控制反转，把创建对象过程交给Spring进行管理
   2. Aop：面向切面，不修改源代码进行功能增强
4. Spring特点
   1. 方便解耦，简化开发
   2. Aop编程支持
   3. 方便程序的测试
   4. 方便和其他框架进行整合
   5. 方便进行事务操作
   6. 降低API开发难度

• 入门案例

IOC容器

• IOC概念和原理
  1. 什么是IOC
     1. 控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理
     2. 使用IOC目的：为了耦合度降低
     3. 做入门案例就是IOC实现
  2. IOC底层原理
     1. xml解析、工厂模式、反射
  3. 画图讲解IOC底层原理
     原始模式：耦合度太高
     
     

1. IOC底层原理

1. IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
2. Spring提供IOC容器实现两种方式：（两个接口）
   1. BaeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供给开发人员进行使用
      • 加载配置文件文件时不会创建对象，在获取对象（使用）才去创建对象
   2. ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员使用
      * 加载配置文件时候会把在配置文件对象进行创建
   3. ApplicationContext接口有实现类
      
3. IOC操作Bean管理
   1. 什么是Bean管理
   1. Bean管理指的是两个操作
   2. Spring创建对象
   3. Spring注入属性
   2. Bean管理操作有两种方式
   1. 基于xml配置文件方式实现
   2. 基于注解方式实现

2. IOC接口（Bean Factory）

3. IOC操作Bean管理（基于xml）

基于xml方式创建对象

<!--配置User对象创建-->
<bean id="user" class="com.ls.User"></bean>

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

基于xml方式注入属性

1. DI：依赖注入，注入属性

• 第一种注入方式：使用set方法进行注入

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

	<!--配置User对象创建-->
	<bean id="user" class="com.ls.User"></bean>
	<!-- set方法注入属性 -->
	<bean id="book" class="com.ls.Book">
	<!--使用property完成属性注入-->
	<property name="属性名" value="属性值"></property>
	</bean>

2. 在spring配置文件配置对象创建，配置属性注入
   • 第二种注入方式：使用有参构造进行注入

   <!-- 有参构造注入属性 -->
   <bean id="orders" class="com.ls.Orders">
   <constructor-arg name="属性" value="属性值"></constructor-arg>
   <constructor-arg index="索引值" value="属性值"></constructor-arg>
   </bean>

   • p名称空间注入（了解）
     1. 使用p名称空间注入，可以简化基于xml配置方式
        1. 添加p名称空间在配置文件中.
           
        2. 进行属性注入，在bean标签里进行操作

           <bean id="book" class="com.ls.Book" p:属性名="属性值"/>

   • xml注入其他类型属性
     1. 字面量
        1. null值

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

     2. 属性值包含特殊符号

        	1. 把<>进行转义 &lt;或&gt;
        	2. 把带特殊符号内容写到CDATA中<![CDATA[]]>

   • 注入属性-外部bean

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

• 注入属性-内部bean和级联赋值
  1. 一对多关系：部门和员工
     • 一个部门有多个员工，一个员工属于一个部门
     • 部门是一，员工是多
  2. 在实体类之间表示一对多关系，员工表示所示部门，使用对象类型属性进行表示

  	public class Dept {
  	String DName;
   
  	public void setDName(String DName) {
  	this.DName = DName;
  		}
  	}
  	public class Emp {
  		String EName;
  		String EGender;
  		Dept dept;
   
  		public void setDept(Dept dept) {
  			this.dept = dept;
  		}
   
  		public void setEName(String EName) {
  			this.EName = EName;
  		}
   
  		public void setEGender(String EGender) {
  			this.EGender = EGender;
  		}
  	}

3. 在spring配置文件中进行配置

    			````xml
    			<!-- 内部bean-->
    				<bean id="emp" class="com.ls.bean.Emp">
    					<!-- 设置两个普通属性-->
    					<property name="EName" value="lucy"></property>
    					<property name="EGender" value="女"></property>
    					<!-- 设置对象类型属性-->
    					<property name="dept">
    						<bean id="dept" class="com.ls.bean.Dept">
    							<property name="DName" value="安保部"></property>
    						</bean>
    					</property>
    				</bean>
    			````
    		4. 级联赋值
    			````xml
    			<!-- 内部bean-->
    				<bean id="emp" class="com.ls.bean.Emp">
    					<!-- 设置两个普通属性-->
    					<property name="EName" value="lucy"></property>
    					<property name="EGender" value="女"></property>
    					<property name="dept" ref="dept"></property>
    					<!-- <property name="dept.name" value="技术部"></property>此方式需要有该对象的get方法-->
    				</bean>
    				<bean id="dept" class="com.ls.bean.Dept">
    					<property name="dname" value="财务部"></property>
    				</bean>
    			````
    		5. IOC操作Bean管理（xml注入集合属性）
    			```java
    			public class Stu {
    				//1.数组类型属性
    				private String[] courses;
    
    				//2.list集合类型属性
    				private List<String> list;
    
    				//3.map集合类型属性
    				private M ap<String,String> maps;
    
    				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;
    				}
    
    				public Stu() {
    				}
    			}
    			```
    			1. 注入数组类型属性
    			2. 注入List集合类型属性
    			3. 注入Map集合类型属性
    			* spring xml文件中的配置
    			```xml
    			<bean id="stu" class="com.ls.bean.Stu">
    					<property name="courses">
    						<array>
    							<value>Java</value>
    							<value>mysql数据库</value>
    						</array>
    					</property>
    					<property name="list">
    						<list>
    							<value>list1</value>
    							<value>list2</value>
    						</list>
    					</property>
    					<property name="maps">
    						<map>
    							<entry key="java" value="java"></entry>
    							<entry key="pHp" value="pHp"></entry>
    						</map>
    					</property>
    				</bean>
    			```
    			5. 把集合注入部分提取出来
    				1. 在spring配置文件中引入名称空间util
    				2. 使用util标签完成list集合注入提取
    				```xml
    					<!-- 提取集合类型属性注入-->
    					<util:list id="bookList">
    						<value>Java</value>
    						<value>python</value>
    					</util:list>
    					<!--提取list集合类型属性注入使用 -->
    					<bean id="book" class="com.ls.Book">
    						<property name="list" ref="bookList"></property>
    					</bean>
    				```

4. IOC操作Bean 管理(FactoryBean)

1. Spring 有两种类型bean，一种普通bean，另外一种工厂bean（FactoryBean）
2. 普通bean:在配置文件中定义bean类型就是返回类型。
3. 工厂bean：在配置文件定义bean 类型可以和返回类型不一样。
   第一步 创建类，让这个类作为工厂bean，实现接口FactoryBean
   第二步 实现接口里面的方法，在实现的方法中定义返回的bean的类型
   代码演示：

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

public class Account implements Serializable {
 
    private Integer id;
    private String name;
    private Double money;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Double getMoney() {
        return money;
    }
 
    public void setMoney(Double money) {
        this.money = money;
    }
 
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}
 
public class MyBean implements FactoryBean<Account> {
 
    //定义返回bean
    @Override
    public Account getObject() throws Exception {
        Account account = new Account();
        account.setId(123);
        return account;
    }
    //
    @Override
    public Class<?> getObjectType() {
        return null;
    }
 
    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}
 
//测试
ctx.getBean("MyBean",Account.class);

IOC操作Bean管理（bean作用域）

1. 在Spring里面，设置创建bean实例是单实例还是多实例。
2. 在Spring里面，默认情况下，bean是一个单实例对象。
3. 如何设置单实例还是多实例
   在spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例：
   第一个值，singleton，表示是单实例的，加载配置文件时，就会创建一个单实例对象
   第二个值，prototype，表示是多实例的，不是在加载spring配置文件对象创建对象，在调用getBean方法时，创建多实例对象
   request 放入web的request中
   session 仿佛web的session中

IOC操作bean管理(bean的生命周期)

1. 生命周期

1. 从对象创建到对象销毁的过程

2.bean的生命周期

1. 通过构造器创建bean实例（无参数构造）
2. 为bean的属性设置值和对其他bean的引用(调用set方法)
3. 调用bean 的初始化的方法（需要进行配置）
4. bean可以使用了（对象获取到了）
5. 当容器关闭时候，调用bean的销毁方法（需要进行配置销毁方法）

3.演示bean的生命周期

public class Orders {
     private  String oName;
 
    public Orders() {
        System.out.println("第一步执行无参构方法");
    }
 
    public void setoName(String oName) {
        this.oName = oName;
        System.out.println("第二步，调用set方法设置属性的值");
    }
 
    //创建执行的初始化方法
    public void initMethod(){
        System.out.println("第三步 执行初始化的方法");
    }
 
    //创建执行的销毁方法
    public void destroyMethod(){
        System.out.println("第五步 执行销毁方法");
    }
}
//main方法中
//        ApplicationContext ctx1 = new ClassPathXmlApplicationContext("bean4.xml");
        ClassPathXmlApplicationContext ctx1 = new ClassPathXmlApplicationContext("bean4.xml");
 
        Orders orders = (Orders) ctx1.getBean("orders");
        System.out.println("第四步 获取创建bean的对象");
        System.out.println(orders);
        //手动让bean 实例销毁
        ctx1.close();

配置文件：

<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/util
        https://www.springframework.org/schema/util/spring-util.xsd">
 
    <context:property-placeholder location="classpath:*.properties"/>
 
    <bean id="orders" class="com.ls.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oName" value="张三"></property>
    </bean>
</beans>

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

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

5.演示后置处理器效果

1. 创建类，实现BeanPostProcessor,创建后置处理器

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

2. 添加配置文件

<bean id="orders" class="com.ls.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oName" value="张三"></property>
    </bean>
    <!-- 配置后置处理器 -->
    <bean id="myBeanPost" class="com.ls.bean.MyBeanPost">
    </bean>

后置处理器会为所有注入的类都添加后置处理器

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

1.什么是自动装配

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

2.演示自动装配过程

1. 根据属性名称自动注入
2. 根据属性类型自动注入

<!-- 实现自动装配
        bean标签autowire,配置自动装配
        autowire属性常用两个值，
        byName根据属性名称进行注入,注入值的id值和类属性名称一样
        byType 根据属性类型进行注入，
     -->
    <bean id="emp" class="com.ls.autowire.Emp" autowire="byName">
<!--        <property name="dept" ref="dept"></property>-->
    </bean>
    <bean id="dept" class="com.ls.autowire.Dept">
 
    </bean>

5. IOC操作Bean管理（外部属性文件）

1、直接配置数据库信息

1. 配置德鲁伊连接池

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=ls200222

2. 引入德鲁伊连接池依赖

<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.16</version>
</dependency>

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

<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/util
        https://www.springframework.org/schema/util/spring-util.xsd">
 <context:property-placeholder location="classpath:*.properties"/>
 
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
 
    <bean id="accountService" class="com.ls.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <!--<property name="dataSource" ref="dataSource"/>-->
    </bean>
 
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.ls.domain"/>
    </bean>
 
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.ls.dao"/>
    </bean>
</beans>

6. IOC操作Bean管理（基于注解）

1.什么是注解

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

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

1. @Component
2. @Service
3. @Controller
4. @Repository

• 上面注解功能一样的，都可以用来创建bean实例

3.基于注解方式创建对象和注入属性

1. 添加环境依赖
2. 开启组件扫描(如果扫描多个包，多个包使用逗号隔开)

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

3. 创建类，在类上添加注解、

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

4. 开启组件细节扫描(use-default-filters="false"表示现在不适用默认filter,自己配置filter context:include-filter,设置扫描那些内容,<context:exclude-filter type="annotation" 不去扫描那些内容)

<context:component-scan base-packag="com.ls" use-default-filters="false">
	<context:include-filter type="annotation"
		expression="org.springframework.stereotype.Controller">
	</context:include-filter>
</context:component-scan>

5. 基于注解方式进行属性注入
   @AutoWired:根据属性类型进行自动装配(spring)
   第一步：把service和dao都加上注解
   第二步:在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解

@Quaifier:根据属性名称进行注入 @Quaifier(value="bean的名称")配合@Component(value="bean名称")进行使用(spring)
这个@Qualifier注解的使用，和上面的@AutoWired一起使用，根据名称和类型进行注入

@Resource:可以根据类型注入@Resource也可以根据名称注入@Resource(name="")(java)

@Value:注入基本类型属性
@Value(value="")

6. 完全注解开发
   1.创建配置类

@Configuration //作为配置类，替代xml配置文件
@Component(basePackage={""})
public class springConfig{
 
}

2. 编写测试类

public void testService(){
	ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
	UserService userService = context.getBean("userService",UserService.class);
	System.out.println(userService);
}

AOP

AOP概念：Aspect Oriented Programming 面向切面编程或者面向方面编程
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
通俗描述：不通过修改源代码方式，在主干功能里面添加新功能

AOP的底层原理

1.AOP底层使用动态代理

有两种情况动态代理
第一种情况 有接口情况，使用jdk动态代理，创建UserDao接口实现类代理对象增强类的方法
第二种情况 动态代理 没有接口情况，使用CGLIB动态代理，创建当前类子类的代理对象，增强类的方法

AOP(JDK动态代理)

1. 使用jdk动态代理，使用Proxy类里面的方法创建代理对象
   1.调用newProxyInstance方法
   static Object newProxyInstance(ClassLoader loader,类<?>[] interfaces, InvocationHandler h)
   返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序
   方法有三个参数：
   第一参数：类加载器
   第二参数，增强方法所在类，这个类实现的接口，支持多个接口
   第三个参数，实现这个接口InvocationHandler，创建代理对象，写增强的部分

2. 编写jdk动态代理方法编写

   1. 创建接口，定义方法
      2.创建接口实现类，实现方法
   2. 使用Proxy类创建接口代理对象

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDao));
    }
}
//创建代理对象代码
class UserDaoProxy implements InvocationHandler{
 
    //1.把创建的是谁的代理对象，把谁传递过来
    //有参数构造传递
    private  Object obj;
    public UserDaoProxy(Object obj){
        this.obj = obj;
    }
    //增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法之前
        System.out.println("方法之前执行..."+method.getName()+"：传递的参数..."+ Arrays.toString(args));
        // 被增强方法执行
        Object res = method.invoke(obj, args);
        // 方法之后
        System.out.println("方法之后执行..."+obj);
        return res;
    }
}

2. AOP术语

   1. 连接点：类里面哪些方法可以被增强，这些方法称为连接点
   2. 切入点：实际被真正增强的方法叫做切入点，比如四个方法可以增强，只增强了一个方法，这个被增强的方法就叫做切入点
   3. 通知（增强）：（1）实际增强的部分称为通知（增强）（2）通知有多种类型：前置通知，后置通知，环绕通知，异常通知，最终通知
   4. 切面：是动作 （1）把通知应用到切入点的过程

3. AOP操作（准备）

   1. Spring框架一般都是基于AspectJ实现AOP操作
      什么是AspectJ:AspectJ不是Spring组成部分，独立AOP框架，一般把ASpectJ和Spring框架一起使用，进行AOP操作
   2. 基于AspectJ实现AOP操作
      （1）基于xml配置文件实现
      （2）基于注解方式实现（使用）
   3. 在项目工程里面引入AOP依赖
   4. 切入点表达式
      （1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
      （2）语法结构：
      execution([权限修饰符][返回类型][类全路径][方法名称][参数列表])
      举例一：对com.ls.dao.bookDao类里面的add方法进行增强
      execution(* com.ls.dao.booDao.add(..))
      举例二：对com.ls.dao.bookDao类里面的所有方法进行增强
      execution(* com.ls.dao.booDao.(..))
      举例三：对com.ls.dao包里面的所有方法，所有类进行增强
      execution( com.ls.dao..(..))

AOP操作（AspectJ注解）

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

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

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

//增强的类
public class UserProxy{
	//前置通知
	public void before(){
		System.out.println("before...")
	}
}

3、进行通知的配置
(1)在spring配置文件中，开启注解扫描

 <!-- 开启注解扫描-->
    <context:component-scan base-package="com.ls.aopanno"></context:component-scan>
 
    <!-- 开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
 

(2)使用注解创建User和UserProxy对象

//被增强类
@Component
public class User {
    public void add(){
        System.out.println("add...");
    }
}
//增强类
@Component
@Aspect //生成代理对象
public class UserProxy {
 
    //前置通知
    //@Before注解表示作为前置通知
    @Before("execution(* com.ls.aopanno.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
    //后置通知
    //@After注解表示作为后置通知
    @After("execution(* com.ls.aopanno.User.add(..))")
    public void after(){
        System.out.println("after...");
    }
    //后置通知（返回通知）
    //@AfterReturning注解表示作为返回值后执行
    @AfterReturning("execution(* com.ls.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }
    //异常通知
    //@AfterThrowing注解表示作为前置通知
    @AfterThrowing("execution(* com.ls.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing...");
    }
    //环绕通知,在之前和之后都执行一次
    //@Around注解表示作为环绕通知
    @Around("execution(* com.ls.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceeding) throws Throwable{
        System.out.println("环绕之前...");
        //被增强的方法执行
        proceeding.proceed();
 
        System.out.println("环绕之后...");
    }
}

(3)在增强类上面添加注解@Aspect
(4)在sping配置文件中开启生成代理对象
(5)配置不同类型的通知
在增强类里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置
4、相同切入点进行配置，对切入点进行抽取

//相同切入点抽取
    @Pointcut(value = "execution(* com.ls.aopanno.User.add(..))")
    public void pointdemo(){
 
    }
 
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value="pointdemo()")
    public void before(){
        System.out.println("before...");
    }

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

@Component
@Aspect
@Order(1)

6、AOP操作(AspectJ配置文件)
1. 创建两个类，增强类和被增强类，创建方法

2. 在spring配置文件中创建两个类对象
```xml
<!--创建两个类的对象-->
<bean id="book" class="com.ls.aopxml.Book"></bean>
<bean id="bookProxy" class="com.ls.aopxml.BookProxy"></bean>
```
3. 在spring配置文件中配置切入点
```xml
<!--配置aop增强-->
<aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.ls.aopxml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!-- 增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
</aop:config>
```

7、纯注解开发
添加配置文件

@Configuration
@ComponentScan(basePackages = {"com.ls"})
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启Aspect生成代理对象
public class ConfigAop {
}

JdbcTemplate

什么是jdbcTemplate

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

引入jdbcTemplate

在applicationContext中引入

<!-- 在数据库中配置数据库连接池-->
<context:property-placeholder location="classpath:*.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
<!--JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

创建service类，创建dao类，在dao注入jdbcTemplate对象(准备工作)

1.配置组件扫描
<context:component-scan base-package="com.ls"/>
2.service对象

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

3.dao对象

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

jdbc操作数据库（添加）（修改和删除操作一样）

（1）在dao进行数据库添加操作
（2）调用JdbcTemplate对象里面update方法实现添加操作
update(String sql,Object... args)
有两个参数
第一个参数：sql语句
第二个参数：可变参数

@Repository
public class BookDaoImpl implements BookDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
 
    @Override
    public void add(User book) {
    //1.创建sql语句
    String sql = "insert into t_user values(?,?,?)";
        int update = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUstatus());
        System.out.println(update);
    }
 
    @Override
    public void updateUser(User user) {
        //1.创建sql语句
        String sql = "update t_user set username= ? where user_id= ? ";
        //执行sql
        int update = jdbcTemplate.update(sql,user.getUsername(),user.getUserId());
        System.out.println(update);
    }
 
    @Override
    public void deleteUser(String id) {
        //1.创建sql语句
        String sql = "delete from t_user where user_id=?";
        //执行sql
        int update = jdbcTemplate.update(sql,id);
        System.out.println(update);
    }
}

jdbc操作数据库（查询返回某个值）

1. 查询表里面有多少条记录，返回的是某个值
   select count(*) from 表名;
2. 使用jdbcTemplate进行查询
   queryForObject(String sql,Class requiredType);
   需要两个参数：
   第一个参数代表sql语句
   第二个参数代表返回值的类型

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

jdbc操作数据库（查询返回对象）

T queryForObject(String var1, RowMapper var2, @Nullable Object... var3) throws DataAccessException;
第一个参数sql
第二个RowMapper，是接口，返回不同类型数据，使用这个接口里面完成数据封装
第三个sql语句值

String sql = "select * from t_book where user_id=?";
  //调用方法
  User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), id);
  return user;
 }

jdbc操作数据库（查询返回集合）

T query(String var1, ResultSetExtractor var2, @Nullable Object... var3) throws DataAccessException;
第一个参数sql
第二个RowMapper，是接口，返回不同类型数据，使用这个接口里面完成数据封装
第三个sql语句值

@Override
    public List<User> findAll() {
        String sql = "select * from t_book";
        List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
        return users;
    }

jdbc操作数据库（批量操作）

1. 批量操作：操作表里面多条记录
   2.jdbcTemplate:实现批量添加操作

String sql ="insert into t_book values(?,?,?)";
  //在执行过程中对 batchArgs进行遍历
  List<Object[]> batch = new ArrayList<>();
  Object[] o1 = {"3","book","a"};
  Object[] o2 = {"4","book","a"};
  Object[] o3 = {"5","book","a"};
  batch.add(o1);
  batch.add(o2);
  batch.add(o3);
  int[]  ints = jdbcTemplate.batchUpdate(sql,batch);
  System.out.println(Arrays.toString(ints));

事务管理

1、什么是事务：事务时数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败，所有操作都失败
2、典型场景，银行转账
3、事务的四大特性（ACID）：
(1). 原子性（Atomicity）：例如，在多线程编程中，如果一个线程执行一个原子操作，这意味着另一个线程无法看到该操作的一半结果。系统只能处于操作之前或操作之后的状态，而不是介于两者之间的状态。 ACID原子性的定义特征是：能够在错误时中止事务，丢弃该事务进行的所有写入变更的能力。
(2). 一致性（Consistency）：ACID一致性的概念是，对数据的一组特定陈述必须始终成立。即不变量（invariants）。例如，在会计系统中，所有账户整体上必须借贷相抵。如果一个事务开始于一个满足这些不变量的有效数据库，且在事务处理期间的任何写入操作都保持这种有效性，那么可以确定，不变量总是满足的。 原子性，隔离性和持久性是数据库的属性，而一致性（在ACID意义上）是应用程序的属性。应用可能依赖数据库的原子性和隔离属性来实现一致性，但这并不仅取决于数据库。
(3). 隔离性（Isolation）：ACID意义上的隔离性意味着，同时执行的事务是相互隔离的：它们不能相互冒犯。如果两个事务不触及相同的数据，它们可以安全地并行（parallel） 运行，因为两者都不依赖于另一个。当一个事务读取由另一个事务同时修改的数据时，或者当两个事务试图同时修改相同的数据时，并发问题（竞争条件）才会出现。出于这个原因，数据库一直试图通过提供事务隔离（transaction isolation） 来隐藏应用程序开发者的并发问题。
(4). 持久性（Durability）：数据库系统的目的是，提供一个安全的地方存储数据，而不用担心丢失。持久性 是一个承诺，即一旦事务成功完成，即使发生硬件故障或数据库崩溃，写入的任何数据也不会丢失。

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

1. 在dao中创建两个方法：一个少钱的方法，一个多钱的方法
2. 在service中创建一个转账的方法：调用dao中的方法

1、创建数据库创建表

2、创建service，搭建dao，完成对象注入

3、使用事务来解决银行转账问题基本过程
（1）. 第一步开启事务
（2）. 进行业务操作
（3）. 如果没有发生异常，提交事务
（4）. 如果出现异常，事务回滚

4. 事务操作（Spring事务管理）
   （1）事务添加到Service层（业务逻辑操作）
   （2）在Spring进行事务管理操作:有两种方式：编程式事务管理（在代码中进行控制）和声明式事务管理（通过配置实现使用）

声明式事务管理

1. Spring事务管理API

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

2. 基于注解方式（常用），底层使用AOP原理。

   1. 在spring配置文件中配置事务管理器
   2. 在spring配置文件，在spring中引入名称空间tx,开启事务注解，
   3. 在service类上边（或者service类里方法上面）添加事务注解，@Transactional//可以加到类上也可以加到方法上边，如果把这个注解添加到类上，这个类里面所有的方法都添加事务，如果把这个注解添加到方法上边，只会为此方法添加事务

<?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"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/util
        https://www.springframework.org/schema/util/spring-util.xsd">
    <!-- 组件扫描 -->
    <context:component-scan base-package="com.ls"></context:component-scan>
 
    <!-- 数据库连接池对象 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db"></property>
        <property name="username" value="root"></property>
        <property name="password" value="ls200222"></property>
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    </bean>
    <!-- JDBCTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
 
<!--    创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
 
    </bean>
    <!--开启事务注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>

声明式事务管理参数配置：
propagation:事务传播行为，当一个事务方法被另一个事务方法调用时候，这个事务方法如何进行。
事务的传播行为可以由传播属性指定。spring定义了7种类传播行为：
REQUIRED:如果事务在运行，当前的方法就在这个事务内运行，否则就启动一个事务，并在自己的事务内运行。

REQUIRED_NEW:当前的方法必须启动新事务，并在它自己的事务内运行，如果有事务正在运行，应该将它挂起

方法B不依赖于方法A
SUPPOERA:如果有事务在运行，当前的方法就在这个事务内运行，否则它可以不运行在事务中

事务的隔离级别：
事务的其中一个特性，隔离性，多个事务之间不会产生影响，不考虑隔离性产生很多问题
有三个读问题：脏读，不可重复读，虚（幻）读
脏读：一个未提交事务读取到另一个未提交事务的数据。
不可重复读：两个事务拿到现同的数据，但一个未提交的事务读取到另一个已提交事务修改数据
虚读：一个未提交事务读取到另一个提交事务添加数据

解决：通过设置事务隔离界别，解决读问题

默认未REPEATABLE(可重复读 )

timeout:超时时间
事务需要在一定时间内进行提交，如果不提交进行回滚
默认值-1，不回滚，以秒为单位

readOnly:是否只读
默认值为false，设置为true只能进行查询

rollbackFor:回滚
rollbackFor =Exception.class
设置出现那些异常进行事务回滚
noRollbackFor:不回滚
设置出现那些异常不进行回滚

3. 基于xml配置文件方式
   在spring配置文件中进行配置：
   第一步配置事务管理器
   第二步配置通知
   第三步配置切入点和切面

 <!--2.配置通知 -->
    <tx:advice id="txadvice">
<!--        配置事务参数-->
        <tx:attributes>
<!--            指定那种规则的方法上面添加事务-->
            <tx:method name="accountMoney" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
<!--    3.配置切入点和切面-->
    <aop:config>
<!--        配置切入点-->
        <aop:pointcut id="pt" expression="execution(* com.ls.service.UserService.*(..))"/>
<!--        配置切面-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"></aop:advisor>
    </aop:config>

事务操作（完全注解开发）

1. 创建配置类

Spring5新特性