Spring总结(IOC、AOP原理以及Spring事务)

一、概述

1、Spring是一个开源免费且轻量级的框架 , 非侵入式的 .

2、控制反转 IoC , 面向切面 Aop

3 、对事物的支持 , 对框架的支持

一句话概括:

Spring 是一个轻量级的控制反转(IOC),面向切面(AOP)的框架

二、Spring下载

Sprig官网:Spring.io 去到官网即可下载

GA:稳定通用版本、SNAPSHOT : 快照版本

Spring历史版本下载地址:https://repo.spring.io/ui/native/release/org/springframework/spring

Spring总结(IOC、AOP原理以及Spring事务)_第1张图片
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EwSGeX8B-1642581545694)(Spring笔记.assets/image-20220116182005242.png)]

Spring5 Runtime 结构示意图

Spring总结(IOC、AOP原理以及Spring事务)_第2张图片

Core 就是我们的Spring的核心 ,如下就是我们如果使用Spring必须导入的Jar包 ,commons-logging必须但不属于Spring;

Spring总结(IOC、AOP原理以及Spring事务)_第3张图片

三、IOC 控制反转

1、IOC底层原理

IOC就是通过 工厂模式 + 反射 + XML解析 实现


<bean id = dao class = "com.sqx.UserDao">bean>
//第二步就是,通过解析配置文件,创建工厂对象,进而创建对象!
class UserDaoFactory{
    public static UserDao getDao(){
        String CalssVlaue = class属性值   // 1、进行xml解析
        Calss clazz = Class.forName(CalssVlaue) ; // 2、通过反射创建对象
        return  (UserDao)clazz.newInstance() ; 
    }
}

我们通常所说的IOC容器本质上就是一个对象工厂,而我们的Spring提供IOC容器实现的两种方式(也就是两个接口,如下)

1、BeanFactory : IOC容器的基本实现,是Spring内部使用的接口,不提供给开发人员使用 ;

  • 加载配置文件的时候,不会创建对象,而是当我们的使用的时候才回去创建对象!

2、ApplicationContext : BeanFactory的子接口提供更多更强大的功能,一般由开发人员进行使用 ; 【推荐】

  • 加载配置文件的时候,会把配置文件中的对象进行创建!

ApplicationContext接口的实现类

查看ApplicationContext接口的继承结构

Spring总结(IOC、AOP原理以及Spring事务)_第4张图片

区别:

  • ClassPathXmlApplicaitonContext : 加载的是我们的src路径下的资源文件
  • FileSyustemXmlApplicationContext: 加载的就是我们系统盘也就是电脑的绝对路径(全路径):如:D:// …

总结

我们通过Spring提供的两种接口 BeanFactory 和 ApplicationContext ,以及其具体的实现类通过读取我们的xml文件创建我们的对象工厂,也就是IOC容器!接下来我们的IOC容器通过反射的方式创建出对象!

2、IOC创建对象的方式

IOC有两种创建对象的方式: 方式一:无参构造 + set注入属性值 ,方式二:有参构造

1、无参构造(默认)


<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="com.kuang.pojo.User">     
       <property name="name" value="kuangshen"/>
   bean>
    
   <bean id="ServiceImpl" class="com.sqx.service.impl.UserServiceImpl">
       
       
       <property name="userDao" ref="OracleImpl"/>
   bean>

beans>

2、有参构造


<bean id="userT" class="com.sqx.pojo.UserT">
   
   <constructor-arg index="0" value="songqixiang"/>
bean>


<bean id="userT" class="com.sqx.pojo.UserT">
   
   <constructor-arg name="name" value="songqixiang"/>
bean>


<bean id="userT" class="com.sqx.pojo.UserT">
   <constructor-arg type="java.lang.String" value="songqixiang"/>
bean>

3、DI依赖注入

DI : 依赖注入(Dependency Injection)也称属性注入 ;

方式一 :使用set方法进行注入 : 我们使用无参构造创建对象,这个类就会通过set方法注入属性,完成对象的创建!

方式二 :使用有参构造进行注入:我们使用有参构造创建的对象对通过构造方法赋值 !

扩展 :p命名和c命名注入

1、P命名空间注入 : 需要在头文件中加入约束文件

 导入约束 : xmlns:p="http://www.springframework.org/schema/p"
 
 
 <bean id="user" class="com.sqx.pojo.User" p:name="狂神" p:age="18"/>

2、c 命名空间注入 : 需要在头文件中加入约束文件

 导入约束 : xmlns:c="http://www.springframework.org/schema/c"
 

 <bean id="user" class="com.sqx.pojo.User" c:name="狂神" c:age="18"/>

其实p命名注入本质上就是我们的set注入,c命名注入本质上则是我们的构造器注入

3.1、注入空值和特殊符号

向我们的对象属性中注入空值

   <bean id="user" class="com.sqx.pojo.User">    
       <property name="name" value="songqixiang"/>
       <property name="address" > <null/> property>  
   bean>

属性值中注入特殊符号

   <bean id="user" class="com.sqx.pojo.User">    
       <property name="name" value="songqixiang"/>
       <property name="address" value="<<南京>>"/>  
       
       
       <property name="address" value="<><<南京>>"/> 
       
       
       <property name="address"> 
           <value>
           		>]]>
           value> 
       property>
   bean>

3、IOC中Bean的类型

IOC创建的Bean分为两种:FactoryBean(工厂Bean) 和 Bean(普通Bean)

FactoryBean 和 Bean的区别:

  • 普通Bean:就是在配置文件中定义的什么类型,经过IOC容器创建后返回的就是什么类型

    	<bean id="user" class="com.sqx.pojo.User">    
           <property name="name" value="songqixiang"/> 
    	bean>
    
  • 工厂Bean:则是IOC创建的类型可以不是xml中定义的类型

    	
        
    	<bean id="myBean" class="com.sqx.factoryBean.MyBean">  bean>
    

    myBean实现FactoryBean

    public class MyBean implements FactoryBean<User> {
    
        /***
         * 定义返回Bean的类型
         * @return
         * @throws Exception
         */
        public User getObject() throws Exception {  //返回类型为一个User,标识这个工厂类只生产User
            User user = new User();
            user.setName("sqx") ;
            return user;
        }
    
        public Class<?> getObjectType() {   
            return null;
        }
    
        public boolean isSingleton() {   //返回值类型
            return false;
        }
    }
    

    通过IOC获取这个MyBean,进行测试 :

        @Test
        public void testFactoryBean(){
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            User myBean = (User) context.getBean("myBean");
            System.out.println(myBean);  // com.sqx.pojo.User@64f6106c 发现MyBean获取的是一个User类
        }
    

4、Bean的作用域

在Spring里面,设置创建Bean实例是单实例(默认)还是多实例

通过标签中scop属性设置我们Bean的作用域,如下:

Spring总结(IOC、AOP原理以及Spring事务)_第5张图片

区别:

  • singleton:单例模式,表示Spring的IOC容器当中只能存在一个Bean实例,默认的。
  • prototype:多实例模式,表示每次从IOC容器当中取一个Bean实例的时候,都是一个新的Bean 。
  • request:每次创建对象,都放在我们的Request域当中(很少用)。
  • session:每次创建对象,都放在我们的session域当中(很少用)。

扩展

关于singletonprototype还存在一个区别就是:

当我们的scop=singleton的时候我们的对象是会在ApplicaitionContex加载xml文件的时候创建的;

当我们的scop=prototype的时候我们的对象不是在加载xml的时候创建的,而是在调用getBean方法的时候创建的!

5、Bean的生命周期

也就是我们Bean对象从创建到销毁的过程

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

演示bean的生命周期

1、编写一个Orders类,为其设置set方法,

public class Orders {

    private String oname ;

    public Orders() {
        System.out.println("第一步:执行无参构造,构建bean的实例");
    }

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步:执行set方法进行属性注入");
    }

    //创建一个执行的初始化方法
    public void initMethod(){
        System.out.println("第三步:执行我们bean的初始化方法");
    }

    //创建一个bean销毁时执行的方法(只有当对象销毁的时候才会调用)
    public void destroyMethod(){
        System.out.println("第五步:执行我们bean的销毁方法");
    }
}

2、编写xml文件

	<bean id="orders" class="com.sqx.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="手机">property>
    bean>

3、编写测试方法,对生命周期进行测试

    @Test
    public void testBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml") ;
        Orders orders = (Orders)context.getBean("orders");
        System.out.println("第四步:获取我们的创建的bean实例");
        System.out.println(orders);

        //让我们bean实例销毁(IOC容器关闭,其中的实例销毁)
        ((ClassPathXmlApplicationContext) context).close();
    }

4、查看测试结果

Spring总结(IOC、AOP原理以及Spring事务)_第6张图片

上述的五步就是我们Bean的生命周期,但是是不考虑后置处理器的情况下是五步,如果考虑的话是如下七步

考虑后置处理器

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

让我们来创建后置处理器来实现我们的3、5步骤

我们只需创建一个后置处理器,然后将处理器注入到我们的IOC容器当中即可,我们的Spring会默认的将其加在IOC容器中的所有bean!

1、创建后置处理器:创建一个类实现BeanPostProcessor接口,并重写两个方法

public class MyBeanPost implements BeanPostProcessor {
    /**
     * bean初始化之前执行的方法!(第三步)
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("bean初始化之前执行的方法!");
        return bean;
    }

    /***
     *  bean初始化之后执行的方法!(第五步骤)
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("bean初始化之后执行的方法!");
        return bean;
    }
}

2、注入到我们的IOC容器

 
 <bean id="myBeanPost" class="com.sqx.bean.MyBeanPost">bean>

测试添加后置处理器的执行结果

Spring总结(IOC、AOP原理以及Spring事务)_第7张图片

可以看到我们的Bean的生命周期就变为七步了!

6、自动装配

我们上边说的是如何将对象注入到IOC容器当中,自动装配简单来说就是自动的从IOC容器中去取对象!

  • 自动装配是使用spring满足bean依赖的一种方法
  • spring会在应用上下文中为某个bean寻找其依赖的bean。

Spring的自动装配需要从两个角度来实现,或者说是两个操作:

  1. 组件扫描(component scanning):spring会自动发现应用上下文中所创建的bean;
  2. 自动装配(autowiring):spring自动满足bean之间的依赖,也就是我们说的IOC/DI;

组件扫描和自动装配组合发挥巨大威力,使得显示的配置降低到最少。

推荐不使用xml配置开启自动装配, 而是使用注解,无论是xml还是注解开启自动装配,都需要先了解一下自动装配的类型:byName 和 byType 这两类,自动装配的类型就是我们从IOC容器中按照什么找到我们所需的bean

6.1、自动装配的类型

自动装配的类型分为两种:byName 和 byType 这两类

  • byName:需要保证所有bean的id是唯一的,并且这个bean需要和自动注入的属性的set方法的名字一致
  • byType:需要保证所有bean的class是唯一的,并且这个bean需要和自动注入的属性的类型一致

知道了自动装配类型的区别,那么就可以学习开启自动装配的两种方式了,如下 :

6.2、自动装配的方式

开启自动装配的方式有,xml配置 和 注解 两种方式!

前提:需要自动装配的属性必须是引用数据类型!

1、XML配置开启自动装配

<bean id="user" class="com.kuang.pojo.User" autowire="byName">  
    <property name="str" value="qinjiang"/>
bean>

<bean id="user" class="com.kuang.pojo.User" autowire="byType">  
    <property name="str" value="qinjiang"/>
bean>


2、注解开启自动装配

注解开启有如下常用注解,将如下主注解放在需要自动装配的属性上即可!

  • @Autowired : 默认是按照类型(ByType)自动装配,如果出现相同类型,可以通过搭配**@Qualifire**指定bean的名称,实现ByName自动装配,@Autowired是Spring的注解!

    public class TestServiceImpl {
      // 下面两种@Autowired只要使用一种即可
      @Autowired
      private UserDao userDao; // 用于字段上
      
      @Autowired
      public void setUserDao(UserDao userDao) { // 用于属性的方法上
        this.userDao = userDao;
      }
    }
    // 实现按照名字自动装配
    public class TestServiceImpl {
      @Autowired
      @Qualifier("userDao")
      private UserDao userDao; 
    }
    
  • @Resource:默认是按照名字(ByName)自动装配的,@Resource有两个重要的属性:name和type,而Spring将@Resource注解的name属性的值解析为bean的名字,而type属性的值则解析为bean的类型。所以,如果使用name属性,则使用byName的自动注入策略,而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性,这时将通过反射机制使用byName自动注入策略。而@Resource是我们Java的原生注解!

    public class TestServiceImpl {
      // 下面两种@Resource只要使用一种即可
      @Resource(name="userDao")
      private UserDao userDao; // 用于字段上
      
      @Resource(name="userDao")
      public void setUserDao(UserDao userDao) { // 用于属性的setter方法上
        this.userDao = userDao;
      }
    }
    

自动装配就这么简单!

扩展一下

@Autowired(required=false) 说明:false,对象可以为null;true,对象必须存对象,不能为null。

//如果允许对象为null,设置required = false,默认为true
  @Autowired(required = false)
  private Cat cat;

7、注解实现DI和对象的创建

前面我们一直通过在xml标签的形式创建对象,接下来我们介绍一下注解的方式创建对象!

1、注解实现对象的创建

Spring提供如下四种注解来实现对象的创建

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

以上四个注解的作用是一样的,都可以用来创建bean,这样分只是为了更好的进行分层。

使用注解的具体步骤:

1、引入AOP的依赖(我们如果使用Maven导入webmvc会自动导入aop)

在这里插入图片描述

2、开启组件扫描(注解扫描,为有注解的类创建对象)

2.1、引入context名称空间:


<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"   
		<context:component-scan base-package="com.kuang.pojo"/>

beans>

2.2、配置扫描哪些包下的注解


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

3、在指定包下编写类,增加注解

//@Component(value="user")  value属性完全可以省略不写!
// 相当于配置文件中 

@Component //默认创建对象的名称就是类型的首字母小写! 例如 class:UserServcice ---> id:userService
public class User {
    public String name = "sqx";
}

4、测试

@Test
public void test(){
    ApplicationContext applicationContext =
        new ClassPathXmlApplicationContext("beans.xml");
    User user = (User) applicationContext.getBean("user");
    System.out.println(user.name);
}

5、开启组件扫描的细节

这一块内容知道就好,通过两个例子演示

  • 样例一:
 
    <context:component-scan base-package="com.sqx" >context:component-scan>

 
    <context:component-scan base-package="com.sqx" use-default-filters="false">
      <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    context:component-scan>
  • 样例二:

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

2、注解实现DI(属性注入)

引用数据类型的属性,通过@Atowired、@Quilifire、@Resource 实现,而基本数据类如何实现DI呢?

@Value :注入普通类型属性

  • 一个样例即可学会:
@Component("user")  // 相当于配置文件中 
public class User {
    @Value("宋淇祥") // 相当于配置文件中 
    public String name;
}

小结一下

XML与注解比较

  • XML可以适用任何场景 ,结构清晰,维护方便
  • 注解不是自己提供的类使用不了,开发简单方便

xml与注解整合开发 :推荐最佳实践

  • xml管理Bean
  • 注解完成属性注入
  • 使用过程中, 可以不用扫描,扫描是为了类上的注解
<context:annotation-config/>  

作用:

  • 进行注解驱动注册,从而使注解生效
  • 用于激活那些已经在spring容器里注册过的bean上面的注解,也就是显示的向Spring注册
  • 如果不扫描包,就需要手动配置bean
  • 如果不加注解驱动,则注入的值为null!

8、通过JavaConfig创建对象

基于Java类进行配置

JavaConfig 原来是 Spring 的一个子项目,它通过 Java 类的方式提供 Bean 的定义信息,在 Spring4 的版本, JavaConfig 已正式成为 Spring4 的核心功能 。

1、编写一个实体类,Dog

@Component  //将这个类标注为Spring的一个组件,放到容器中!
public class Dog {
    public String name = "dog";
}

2、新建一个config配置包,编写一个MyConfig配置类

@Configuration  //代表这是一个配置类
public class MyConfig {
 
    @Bean //通过方法注册一个bean,这里的返回值就Bean的类型,方法名就是bean的id!
    public Dog dog(){
        return new Dog();
    }
}

3、测试

@Test
public void test2(){
    ApplicationContext applicationContext =
            new AnnotationConfigApplicationContext(MyConfig.class);
    Dog dog = (Dog) applicationContext.getBean("dog");
    System.out.println(dog.name);
}

关于这种Java类的配置方式,我们在之后的SpringBoot 和 SpringCloud中还会大量看到,我们需要知道这些注解的作用即可!

四、AOP 面向切面

面向切面编程(方面),利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分耦合度降低,提高开发效率!

通俗描述:在不修改源代码的方式,在主干功能当中添加新功能!

Spring总结(IOC、AOP原理以及Spring事务)_第8张图片

1、AOP底层原理

AOP的底层就是动态代理,而其动态代理也根据情况的不同分为JDK动态代理CGLIB动态代理

  • 有接口,JDK动态代理

    Spring总结(IOC、AOP原理以及Spring事务)_第9张图片

  • 无接口,CGLIB动态代理

    Spring总结(IOC、AOP原理以及Spring事务)_第10张图片

2、JDK动态代理的实现

JDK动态代理是在有接口的情况下使用,所以我们需要先创建接口实现类的代理对象,这一步通过Proxy的方法可以实现!

Proxyjava.lang.reflect.Proxy

在这里插入图片描述

方法有三个参数:

1、类加载器

2、增强方法所在的类,这个类的接口 ,支持多个接口

3、实现这个接口InvocationHandler ,创建代理对象,写增强方法

具体的实现步骤

1、编写一个接口,UserDao

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

    String update(String id)  ;
}

2、创建接口的实现类,UserDaoImpl

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

    public String update(String id) {
        return id ;
    }
}

3、通过Proxy创建代理类,实现方法增强

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类的代理对象
        Class[] interfaces = { UserDao.class } ;
        UserDaoImpl userDaoImpl = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, 
                                                       	new UserDaoProxy(userDaoImpl));// invoke方法自动调用
        int result = dao.add(1,2) ;
        System.out.println("result:"+result);
    }
}

//创建代理对象的代码
class UserDaoProxy implements InvocationHandler{

    //1、创建的是谁的代理对象,把谁传进来
    //有参构造传递
        private Object obj  ;
        public UserDaoProxy(Object obj) {
            this.obj = obj ;
        }

    //增强的逻辑
    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;
    }
}

4、测试结果,实现方法增强!

3、AOP术语

介绍一下AOP当中的的相关术语,例如:发动机术语是引擎

1、连接点 :类里面的哪些方法可以被增强,这些方法称为连接点 ;

2、切入点:实际被真正增强的方法,称为切入点 ;

3、通知(增强):实际增强的逻辑部分就称为通知 ;通知也分5种:前置通知 、后置通知 、环绕通知、异常通知、最终通知!

4、切面是一个动作,指的是将通知应用到切入点的过程!

4、AOP操作(AspectJ)

Spring框架一般都是基于Aspectj实现AOP操作!

1、什么是AspectJ ?

  • AspectJ不是Spring的组成部分,独立AOP框架,一般把AspectJ和Spring框架一起使用,进行AOP操作!

2、基于Aspectj实现AOP操作的方式

  • 基于xml配置文件实现
  • 基于注解的方式实现(推荐)

4.1、实现AOP操作的准备

如下开始使用Spring 和 AjpectJ 来实现AOP的操作!

1、环境准备:Ajpectj + Spring

     
		<dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>5.2.0.RELEASEversion>
        dependency>
	
        <dependency>
            <groupId>org.aspectjgroupId>
            <artifactId>aspectjweaverartifactId>
            <version>1.9.4version>
        dependency>

2、切入点表达式

  • 切入点表达式的作用:知道对哪个类里面的哪个方法进行增强
  • 语法结构:
execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表])) //类全路径:类的全限定名

例1:对com.sqx.dao.BookDao类里面的add方法进行增强

execution(* com.sqx.dao.BookDao.add(..)) // * 表示任意权限修饰符 

例2:对com.sqx.dao.BookDao类里面的所有方法进行增强

execution(* com.sqx.dao.BookDao.*(..)) // * 表示任意权限修饰符 

例3:对com.sqx.dao包里面的所有类,类里面的所有方法进行增强

execution(* com.sqx.dao.*.*(..)) // * 表示任意权限修饰符 

4.2、AOP操作(AspectJ注解)

通过AspectJ注解的方式实现AOP操作

1、创建一个类,在类中定义方法

public class User {
    public void add(){
        System.out.println("add方法执行....");
    }
}

2、创建增强类(编写增强逻辑)

/***
 * User增强类
 */
public class UserProxy {

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

3、进行通知的配置

3.1、在Spring配置文件,开启注解扫描

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

3.2、使用注解创建User和ProxyUser:也就是在类的上边加上@Component

@Component
public class User { ... }

3.3、在增强类上添加一个注解 @AspectJ

/***
 * User增强类
 */
@Component
@Aspect   //为增强类生成一个代理对象
public class UserProxy {

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

3.4、在Spring配置中开启生成代理对象:同时需要引入aop的命名空间


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

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

beans>

3.5、配置不同类型的通知

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

/***
 * User增强类
 */
@Component
@Aspect   //生成增强类的代理对象
public class UserProxy {

    //前置通知
    @Before(value = "execution(* com.sqx.annot.User.add())")  // 表示方法作为前置通知切入到add()方法
    public void before(){
        System.out.println("before.......");
    }
}

2、进行测试

Spring总结(IOC、AOP原理以及Spring事务)_第11张图片

方法增强成功!

4、剩余的配置细节

对以上通知类型都进行测试,我么看一下有什么问题?

Spring总结(IOC、AOP原理以及Spring事务)_第12张图片

①、我们发现,我们为一个切点多次增强,切入点表达式出现冗余,因此,我们可以将切点表达式抽取出来,生成一个公共切入点

1、定义公共切入点:

    @Pointcut(value = "execution(* com.sqx.annot.User.add())")
    public void pointDemo(){

    }

2、使用公共切入点:

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

以上就解决了我们的切入点冗余的问题!

②、如果出现如下情况:多个增强类对同一个方法进行增强,我们需要制定其优先级

Spring总结(IOC、AOP原理以及Spring事务)_第13张图片

我们通过@Order注解来设置增强类优先级:这个值越小优先级越高!

@Order(3)
public class UserProxy {}

@Order(1)
public class PersonProxy {}

执行测试,查看结果

Spring总结(IOC、AOP原理以及Spring事务)_第14张图片

4.3、AOP操作(AspectJ配置文件)

通过xml配置文件的方式实现AOP操作(很少使用,了解即可!)

五、Spring事务

事务一般添加到JavaEE三层结构里面的Service层(业务逻辑层)

Spring事务管理的两种方式:1、编程式事务管理 2、声明式事务管理(推荐)

区别:编程式事务管理,是我们通过代码保证我们的事务,显得比较臃肿,因此推荐声明式事务管理

1、编程式事务管理

如下是编程式事务的一个演示:

//模拟一下转账操作,小明向小红转账300 ;
public void accountMony(){
	try{
    	UserDao.addmony() 	     //小明的余额添加300
    	UserDao.reducemony()     //小红的余额减去300
	 }catche(Exception){
    	//回滚
	}
}

2、声明式事务管理

声明式事务的使用方式有如两种:

  • 基于注解的方式【方便、简单、推荐】
  • 基于xml配置文件方式

声明式事务的底层,使用的就是我们的AOP原理

Spring事务管理的一些API :

PlatformTransactionManager //事务管理器的接口,根据整合不同的框架采不同的实现类(事务管理器)

Spring总结(IOC、AOP原理以及Spring事务)_第15张图片

如果我们的Spring整合了Mybatis 、jdbcTemplate都是使用的DataSourceTransactionManger这个事务管理器!

2.1、注解方式实现

1、配置Spring的事务管理器

    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="datasource"/>  
    bean>

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


xmlns:tx="http://www.springframework.org/schema/context"      
http://www.springframework.org/schema/tx https://www.springframework.org/schema/aop/spring-tx.xsd
   
<tx:annotation-driven transaction-manager="transactionManager">tx:annotation-driven>

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

  • @Transactional,这个注解可以加在类上边,也可以加在方法上面
  • 如果把这个注解添加在类上面:这个类里面所有方法都添加事务
  • 如果把这个注解添加在方法上面:为这个方法添加事务
@Transactional
public class UserServiceImpl { }


public class UserServiceImpl { 
	@Transactional
    void UpdateUserInfo(User User){ }
}

到此,我们的声明式事务,通过注解的方式就已经开启了!

@Transactional扩展 : 了解一个这个注解的一些属性参数

Spring总结(IOC、AOP原理以及Spring事务)_第16张图片

常用的有如下:

  • propagation :事务的传播行为

    指的是事务方法(对数据库表中数据发生改变的方法,统称事务方法),之间的相互调用!

    @Transactional
    public void add() {	
    	update() ; //调用update方法   这时候引出的一个问题add方法中开启了事务,但是调用了update方法,事务是如何管理的!
    }
    
    public void upodate() {}
    

    事务的传播行为有七种:

    参考文章:https://blog.csdn.net/weixin_39625809/article/details/80707695

    Spring总结(IOC、AOP原理以及Spring事务)_第17张图片

  • isolation:事务隔离级别

    • 在此处主要是指的多个开启事务的方法的并发问题,本质还是跟我们MySQL中的事务隔离级别一致!
  • timeout:超时时间

    • 事务需要在一定时间内进行提交,如果说在这一段时间内不提交,就会发生回滚!
    • 默认值是-1 , 设置时间以秒为单位
  • readOnly:是否只读

    • 读:查询操作,写:增删改操作’
    • 默认值为false , 表示当前事务当中可以查询可以查询和增删改操作
    • 设置为true , 当前事务中只支持读操作
  • rollbackFor:回滚

    • 设置出现哪些异常,执行回滚
  • noRollbackFor:不回滚

    • 设置出现哪些异常,不执行回滚

2.2、xml配置文件方式实现

实际开发,我们依然是用注解,但是xml配置方式仍需了解一下!

前提:声明式事务本质还是aop实现的,我们注解只是代替了我们手动切入事务的这个步骤,xml则需要我们手动的完成这个步骤!

1、依然是配置我们事务管理器

    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    bean>

    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="datasource"/>
    bean>

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.sqx.service.UserService.*(..))"/>
        
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    aop:config>

xml配置文件方式实现声明式事务完成!

2.3、完全注解实现

通过JavaConfig的方式配置我们所有信息,无需要xml文件

@Configuration
@ComponentScan(basePackages = "com.sqx")
@EnableTransactionManagement   // 开启事务管理
public class MyConfig {

        //创建一个数据库的连接池对象
        @Bean
        public DruidDataSource getDruidDataSource(){
                DruidDataSource dataSource = new DruidDataSource();
                dataSource.setDriverClassName("com.mysql.jdbc.Driver");
                dataSource.setUrl("jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8");
                dataSource.setUsername("root");
                dataSource.setPassword("123456");
                return dataSource;
        }

        //创建一个JdbcTemplate对象
        @Bean
        public JdbcTemplate getJdbcTemplate(DataSource dataSource){  //此处会按照类型自动装配,接收DataSource对象
                JdbcTemplate jdbcTemplate = new JdbcTemplate();
                jdbcTemplate.setDataSource(dataSource);
                return jdbcTemplate ;
        }

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

}

需要注意:

Spring总结(IOC、AOP原理以及Spring事务)_第18张图片

事务相关就到此完结!

六、Spring整合日志框架

Spring5 框架自带了通用的日志封装,而且也能整合其他日志工具 如 : Log4j 、Log4j2

由于Spring5 移除了Log4j CofigerListener(使用Log4j的核心),如果需要Log4j 要将Spinrg5降为4版本,所以官方建议使用Log4j2

参考文章:https://blog.csdn.net/zjh2016/article/details/103170578

1、整合Log4j2日志

1、引入相关依赖

需要导入如下的4个依赖,才能使用Log4j2

<dependency>
    <groupId>org.slf4jgroupId>
    <artifactId>slf4j-apiartifactId>
    <version>1.8.0-alpha2version>
dependency>
<dependency>
    <groupId>org.apache.logging.log4jgroupId>
    <artifactId>log4j-slf4j-implartifactId>
    <version>2.10.0version>
dependency>
<dependency>
    <groupId>org.apache.logging.log4jgroupId>
    <artifactId>log4j-apiartifactId>
    <version>2.10.0version>
dependency>
<dependency>
    <groupId>org.apache.logging.log4jgroupId>
    <artifactId>log4j-coreartifactId>
    <version>2.10.0version>
dependency>

2、创建Log4j2.xml配置文件

配置都是如下:




<configuration status="WARN">
    
    <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>
    
    
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
        root>
    loggers>
configuration>

到这里我们Log4j2就已经开启了,但是如果我们呢想要手动使用Log4j2呢?

3、进行如图操作就好了

就如下两步即可!

Spring总结(IOC、AOP原理以及Spring事务)_第19张图片

    private static final Logger log = LoggerFactory.getLogger(MyTest.class) ;

	log.info("hello Log4j2");
    log.debug("hello Log4j2");
    log.warn("hello Log4j2");
    log.error("hello Log4j2");
    log.trace("hello Log4j2");

完结!

七、Spring整合单元测试框架

常见的单元测试框架JUnit4 、JUnit5 我们的Spring5 都是支持的,我们逐个测试!

参考文章:https://blog.csdn.net/sinat_32336967/article/details/112275292

前提:先准备Spring5的环境

    	
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webartifactId>
            <version>5.2.5.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.2.5.RELEASEversion>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-testartifactId>
            <version>5.2.5.RELEASEversion>
            <scope>testscope>
        dependency>

1、整合JUnit4测试

1、导入相关依赖

	  
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>
       

2、Spring5+Junit4单元测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classpath = "beans.xml")
public class AppConfigurationTest {

    @Autowired
    private RestTemplate restTemplate;
    
    @org.junit.Test
    public void restTemplate() {
        System.out.println(restTemplate);
        ResponseEntity<String> res = restTemplate.getForEntity("https://www.baidu.com", String.class);
        System.out.println(res.getBody());
    }
}

2、整合JUnit5测试

1、引入相关依赖

        
        <dependency>
            <groupId>org.junit.jupitergroupId>
            <artifactId>junit-jupiter-apiartifactId>
            
            <version>RELEASEversion>
            <scope>compilescope>
        dependency>

2、Spring5+Junit5单元测试代码

 //下面两个注解可以用@SpringJunitConfig(AppConfiguration.class)替代
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = AppConfiguration.class)  //加载的JavaConig配置类,也可以classpath = "beans.xml"
public class AppConfigurationTest {

    @Autowired
    private RestTemplate restTemplate;

    @org.junit.jupiter.api.Test
    public void restTemplate() {
        System.out.println(">>>>>>>>>"+restTemplate);
        ResponseEntity<String> res = restTemplate.getForEntity("https://www.jd.com", String.class);
        System.out.println(res.getBody());
    }
}

3、总结

不同点

1、使用注解不同

Spring5+Junit4时,使用如下两个注解:

  • @RunWith(SpringJUnit4ClassRunner.class)
  • @org.junit.Test

Spring5+Junit5时,使用如下两个注解:

  • @ExtendWith(SpringExtension.class)
  • @org.junit.jupiter.api.Test

2、整合时使用的启动类不同

  • 整合Junit4时是:org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  • 整合Junit5时是:org.springframework.test.context.junit.jupiter.SpringExtension;

两者均是spring-test包中提供的类。

相同点

加载配置类或者配置文件均使用注解 :

@ContextConfiguration(classes = AppConfiguration.class) 或者 @ContextConfiguration(classpath = “beans.xml”)

注意事项:在使用Spring5时,Junit版本最低为4.12,否则就会报错。

你可能感兴趣的:(后端,Spring系列,spring,java,ioc,aop,事务)