Spring原码讲解

最新推荐文章于 2024-07-23 08:50:23 发布
最新推荐文章于 2024-07-23 08:50:23 发布
阅读量204 收藏
点赞数
文章标签： Spring框架 IOC AOP 依赖注入 事务管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljx1129071273/article/details/120339762
版权

Spring核心讲解

1、Spring框架概述

  • Spring是轻量级的开源的JavaEE框架

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

  • Spring有许多组成部分 核心IOC和AOP

  • IOC:控制反转 把创建对象的过程交给Spring进行管理

  • AOP: 面向切面 不修改源代码进行功能增强

  1. 方便解耦 简便开发
  2. AOP编程支持
  3. 方便unit测试
  4. 可以方便和其他框架进行集合
  5. 支持事务处理以及降低API的开发难度

2、入门案例

1、下载Spring5

在这里插入图片描述

2、选择地址进行下载

在这里插入图片描述

3、复制这个地址

在这里插入图片描述

下载地址https://repo.spring.io/ui/native/release/org/springframework/spring

4、源码解压

在这里插入图片描述

JAR包分为三类:

  • .jar基本jar包
  • .javadoc 文档包
  • .source源代码包

这里我们主要研究四个

  • Beans 对应IOC
  • Core 对应IOC
  • Context 对应上下文
  • Expression 对应表达式

5、JAR包导入

在这里插入图片描述

6、使用Spring方式创建对象

6.1 测试 使用普通类进行创建对象

/**
 * @author
 * @Package com.ljx.spring5
 * @date 2021-09-14 15:26
 */
public class User {
    public void add(){
        System.out.println("add....");
    }
}
User user = new User();

6.2 使用Spring方式创建

1.通过配置文件 在配置文件里面创建对象

<?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">
<!--  配置User创建  -->
    <bean id="user" class="com.ljx.spring5.User"></bean>
</beans>

通过这个bean实现了对象的创建

2、测试对象的编写

package com.ljx.test;

import com.ljx.spring5.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author ljx
 * @Package com.ljx.test
 * @date 2021-09-14 15:45
 */
public class TestSpring5 {

    @Test
    public void test01(){
        // 加载Spring的配置文件  在src下直接写名称 不在的话需要写具体路径
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("bean1.xml");
        //获取配置创建的对象  这个user是对应的bean的Id
        User user = applicationContext.getBean("user", User.class);
        System.out.println(user);
    }

}

测试Spring创建对象

3、IOC容器

3.1、IOC底层原理

1、什么是IOC

  • 控制反转也可以被称为依赖注入,把对象创建和对象之间的调用过程交给Spring进行管理

  • 为什么使用：为了降低耦合度

  • 上面的案例就是IOC的实现

2、IOC底层原理

(1)xml解析、工厂模式、反射

原始创建对象的方式
在这里插入图片描述

使用IOC的过程

在这里插入图片描述

3、IOC接口

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

2、Spring提供了两种方式

  • BeanFactory： IOC最基本的实现方式 是Spring 内部使用的接口 不提供开发使用

加载配置文件的时候是不会创建对象，只有获取对象才会去创建对象

  • ApplicationContext：BeanFactory接口的子接口 一般是由开发人员进行使用的

加载配置文件的时候 就会把对象给创建出来

3、ApplicationContext实现类

在这里插入图片描述

  • FileSystemXmlApplicationContext 指的是配置文件的带盘符的路径
  • ClassPathXmlApplicationContext 指的是配置文件的类路径 也就是src的路径

4、BeanFactory接口实现类

在这里插入图片描述

3.2、IOC接口(BeanFactory)

IOC操作Bean管理

1、Bean管理

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

2、Bean管理的两种操作方式

(1) 基于xml配置文件的方式进行注入

(2)使用注解的方式进行注入

3、基于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">
<!--  配置User创建  -->
<!--  bean的属性讲解
    id: 给一个对象起一个表示  根据这个表示可以获取对象
    class:属性 类的全路径
  -->
<!-- 没有设置参数的时候默认会执行无参的构建   -->
    <bean id="user" class="com.ljx.spring5.User">
    </bean>
<!--  基于XML的方式注入属性
    1、DI 依赖注入 就是注入属性  是IOC的一种具体实现  前提是在对象已经创建的基础上
-->
</beans>

3.3、IOC的Bean管理(基于XML)

1、在配置文件中先实现对象创建

2、注入属性

通过set方法注入
<?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">
<!--  配置User创建  -->
<!--  bean的属性讲解
    id: 给一个对象起一个表示  根据这个表示可以获取对象
    class:属性 类的全路径
  -->
<!-- 没有设置参数的时候默认会执行无参的构建   -->
    <bean id="user" class="com.ljx.spring5.User">
        <property name="userName" value="ljx"/>
    </bean>
<!--  基于XML的方式注入属性
    1、DI 依赖注入 就是注入属性  是IOC的一种具体实现  前提是在对象已经创建的基础上
name 是属性名称  value是设置的值
-->
</beans>
前提是对象里面要有Set方法  注入属性就相当于设置对应的Set方法

编写对应的测试类

 @Test
    public void test02(){
        // 加载Spring的配置文件  在src下直接写名称 不在的话需要写具体路径
        BeanFactory applicationContext=new ClassPathXmlApplicationContext("bean1.xml");
        //获取配置创建的对象  这个user是对应的bean的Id
        User user = applicationContext.getBean("user", User.class);
        String userName = user.getUserName();
        System.out.println(userName);
    }
通过构造方法注入
<?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">
<!--  配置User创建  -->
<!--  bean的属性讲解
    id: 给一个对象起一个表示  根据这个表示可以获取对象
    class:属性 类的全路径
  -->
<!-- 没有设置参数的时候默认会执行无参的构建   -->
    <bean id="user" class="com.ljx.spring5.User">
<!--        <property name="userName" value="ljx"/>-->
        <constructor-arg name="userName" value="ljx"/>
    </bean>
<!--  基于XML的方式注入属性
    1、DI 依赖注入 就是注入属性  是IOC的一种具体实现  前提是在对象已经创建的基础上
-->
</beans>

编写对应测试类

@Test
    public void test02(){
        // 加载Spring的配置文件  在src下直接写名称 不在的话需要写具体路径
        BeanFactory applicationContext=new ClassPathXmlApplicationContext("bean1.xml");
        //获取配置创建的对象  这个user是对应的bean的Id
        User user = applicationContext.getBean("user", User.class);
        String userName = user.getUserName();
        System.out.println(userName);
    }

注入其他类型的属性

<?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">
    <!--  配置User创建  -->
    <!--  bean的属性讲解
        id: 给一个对象起一个表示  根据这个表示可以获取对象
        class:属性 类的全路径
      -->
    <!-- 没有设置参数的时候默认会执行无参的构建   -->
    <bean id="user" class="com.ljx.spring5.User">
        <property name="userName" value="李加喜"/>
        <property name="address">
            <!--    为属性设置空值        -->
            <null/>
        </property>
        <!--   属性值设置了特殊符号     -->
        <!--        <constructor-arg name="userName" value="李加喜"/>-->
        <property name="userId">
            <value>
                <![CDATA[<<用户Id]>>]]>
            </value>
        </property>
    </bean>
    <!--  基于XML的方式注入属性
        1、DI 依赖注入 就是注入属性  是IOC的一种具体实现  前提是在对象已经创建的基础上
    -->
</beans>
注入属性-外部bean

创建dao和daoImpl

public interface UserDao {
    /**
     * 修改
     */
    void update();
}
public class UserDaoImpl implements UserDao {

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

创建service里面引入dao

public class UserService {
    // 创建UserDao类型的属性  生成对应的Set方法
    private UserDao userDao1;

    public UserDao getUserDao1() {
        return userDao1;
    }

    public void setUserDao1(UserDao userDao1) {
        this.userDao1 = userDao1;
    }

    public void add(){
        System.out.println("测试 add...");
        userDao1.update();
    }
}

配置文件里面进行引入

<?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">
    <!--  创建service和dao对象  -->
    <bean id="userService" class="com.ljx.service.UserService">
        <!--   name是属性的名字  res是类里面属性的名称     -->
        <property name="userDao1" ref="userDao"/>
    </bean>
    <！----这里引入的是接口的实现类接口是不允许进行实例化的----!>
    <bean id="userDao" class="com.ljx.dao.UserDaoImpl"/>
</beans>
FactoryBean

Spring里面有两种Bean 一种普通的一种工厂Bean(FactoryBean)

  • 普通Bean定义的类型就是自己定义的类型
  • 工厂Bean 在配置文件里面定义的bean类型可以和返回类型不一样

第一步:创建一个类 让这个类作为工厂bean 实现接口FactoryBean

第二步:实现接口里面的方法 在实现的方法中定义返回的bean类型

package com.ljx.factorybean;

import com.ljx.spring5.User;
import org.springframework.beans.factory.FactoryBean;

/**
 * @author
 * @Package com.ljx.factorybean
 * @date 2021-09-16 15:08
 */
public class MyBean implements FactoryBean<User> {

    /**
     * 定义返回的Bean
     * @return
     * @throws Exception
     */
    @Override
    public User getObject() throws Exception {
        User user = new User();
        user.setUserName("ljx");
        return user;
    }

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

配置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 id="myBean" class="com.ljx.factorybean.MyBean"></bean>
</beans>

编写测试类

@Test
    public void testCollection() {
        // 加载Spring的配置文件  在src下直接写名称 不在的话需要写具体路径
        BeanFactory applicationContext = new ClassPathXmlApplicationContext("bean3.xml");
        //获取配置创建的对象  这个user是对应的bean的Id
        User myBean = applicationContext.getBean("myBean", User.class);
        System.out.println(myBean);
    }
bean的作用域

可以设置 bean是单实例还是多实例

Spring默认是单实例的

@Test
    public void testBook(){
        // 加载Spring的配置文件  在src下直接写名称 不在的话需要写具体路径
        BeanFactory applicationContext = new ClassPathXmlApplicationContext("bean3.xml");
        //获取配置创建的对象  这个user是对应的bean的Id
        Book book = applicationContext.getBean("book", Book.class);
        System.out.println(book);
        Book book1 = applicationContext.getBean("book", Book.class);
        System.out.println(book.equals(book1));
    }

返回结果是true 所以默认是单实例的

设置对象是多实例对象

设置配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="myBean" class="com.ljx.factorybean.MyBean"></bean>
    <bean id="book" class="com.ljx.factorybean.Book" scope="prototype"></bean>
</beans>
prototype:是多实例
singleton:是单实例

编写测试文件

@Test
    public void testBook(){
        // 加载Spring的配置文件  在src下直接写名称 不在的话需要写具体路径
        BeanFactory applicationContext = new ClassPathXmlApplicationContext("bean3.xml");
        //获取配置创建的对象  这个user是对应的bean的Id
        Book book = applicationContext.getBean("book", Book.class);
        System.out.println(book);
        Book book1 = applicationContext.getBean("book", Book.class);
        System.out.println(book.equals(book1));
    }
是false  说明当前是多实例的
bean的生命周期

1、生命周期

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

2、bean的生命周期

  • 通过构造器创建bean的实例(无参构造)
  • 为bean的属性设置值和对其他bean进行引用(调用set方法)
  • 调用bean的初始化方法
  • bean可以进行获取了
  • 当容器管理之后 调用bean的销毁方法
package com.ljx.bean;

/**
 * @author 李加喜
 * @Package com.ljx.bean
 * @date 2021-09-16 21:48
 */
public class Orders {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("第二步 调用set设置值");
        this.name = name;
    }

    public Orders(String name) {
        this.name = name;
    }
    public Orders(){
        System.out.println("第一步 执行无参数构造 构造创建bean");
    }

    // 创建初始化方法
    public void initMethod(){
        System.out.println("第三步调用自定义初始化方法");
    }
    /**
     * 执行销毁方法
     */
    public void destroyMethod(){
        System.out.println("第五步 调用销毁方法");
    }
}

编配配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="orders" class="com.ljx.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="名称"/>
    </bean>
</beans>

测试

@Test
    public void testOrders(){
        // 加载Spring的配置文件  在src下直接写名称 不在的话需要写具体路径
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean4.xml");
        //获取配置创建的对象  这个user是对应的bean的Id
        Orders orders = applicationContext.getBean("orders", Orders.class);
        System.out.println("第四步 获取bean实例对象");
        System.out.println(orders);
        // 手动销毁
        applicationContext.close();
    }

结果
第一步 执行无参数构造 构造创建bean
第二步 调用set设置值
第三步调用自定义初始化方法
第四步 获取bean实例对象
com.ljx.bean.Orders@64f6106c
第五步 调用销毁方法

3、bean的后置处理器 (总共七步)

  • 通过构造器创建bean的实例(无参构造)
  • 为bean的属性设置值和对其他bean进行引用(调用set方法)
  • 将bean的实例传递给后置处理器(postProcessBeforeInitialization)
  • 调用bean的初始化方法
  • 将bean的实例传递给后置处理器(postProcessAfterInitialization)
  • bean可以进行获取了
  • 当容器管理之后 调用bean的销毁方法

创建类 实现接口BeanPostProcessor 创建后置处理器

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之前 postProcessBeforeInitialization");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之后postProcessAfterInitialization");
        return bean;
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="orders" class="com.ljx.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="名称"/>
    </bean>
    <bean id="beanPost" class="com.ljx.bean.MyBeanPost"></bean>
</beans>

这样容器里面的所有Bean都会执行这个方法

基于xml的自动装配
  1. 根据指定的装配规则(属性名称/属性类型) Spring自动将匹配的属性值进行注入
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="orders" class="com.ljx.bean.Orders" init-method="initMethod"
          destroy-method="destroyMethod">
        <property name="name" value="名称"/>
    </bean>
    <bean id="beanPost" class="com.ljx.bean.MyBeanPost"></bean>
    <!-- byName 根据属性名进行注入  注入的值的bean的id要和类的属性名称一致
         byType 根据类型进行注入  找到属性的类型在管理的对象里面进行注入 
          注意 如果出现相同类型的两个bean 就会出去错误 -->
    <bean id="emp" class="com.ljx.bean.Emp" autowire="byName">
        <!--        <property name="dept" ref="dept"/>-->
    </bean>
    <bean id="dept" class="com.ljx.bean.Dept"></bean>
</beans>

类型

package com.ljx.bean;

import java.util.Date;

/**
 * @author 李加喜
 * @Package com.ljx.bean
 * @date 2021-09-16 22:59
 */
public class Emp {
    private Dept dept;

    public Dept getDept() {
        return dept;
    }

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

    @Override
    public String toString() {
        return "Emp{" +
                "dept=" + dept +
                '}';
    }
    public  void test(){
        System.out.println(dept);
    }
}

public class Dept {
    @Override
    public String toString() {
        return "Dept{}";
    }

}

package com.ljx.bean;

import java.util.Date;

/**
 * @author 李加喜
 * @Package com.ljx.bean
 * @date 2021-09-16 22:59
 */
public class Emp {
    private Dept dept;

    public Dept getDept() {
        return dept;
    }

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

    @Override
    public String toString() {
        return "Emp{" +
                "dept=" + dept +
                '}';
    }
    public  void test(){
        System.out.println(dept);
    }
}

public class Dept {
    @Override
    public String toString() {
        return "Dept{}";
    }

}

3.4、IOC的Bean管理()基于注解

1、创建对象提供的注解

  • @Service

  • @Component

  • @Controller

  • @Reposibility

上面的四个注解都可以用来创建bean实例

2、基于注解实现对象的创建

第一步、引入依赖

spring-aop-5.2.6.RELEASE.jar引入这个jar包

第二步、开启组件扫描

<?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">
    <bean id="dept" class="com.ljx.bean.Dept"></bean>
	<!--    开启组件扫描		-->
    <context:component-scan base-package="com.ljx"/>
</beans>

第三步 创建类 在类上面添加创建对象的注解

@Component(value="可以是自定义名称 默认是类的首字母小写")
public class Pfm {
    public void add(){
        System.out.println("add");
    }
}

第四步 测试

@Test
    public void pfm(){
        // 加载Spring的配置文件  在src下直接写名称 不在的话需要写具体路径
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean4.xml");
        //获取配置创建的对象  这个user是对应的bean的Id
        Pfm pfm = applicationContext.getBean("pfm", Pfm.class);
        pfm.add();
    }

3、组件扫描的细节配置

<!--    开启组件扫描-->
    <context:component-scan base-package="com.ljx"/>
<!--  use-default-filters="false" 表示不使用默认的filter 自己配置filter
      context:include-filter  设置需要扫描那些配置类  这类的配置只会扫描带有Controller的类
-->
    <context:component-scan base-package="com.ljx" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>
<!--只扫描包含Component的类-->
    <context:component-scan base-package="com.ljx" >
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>

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

1、@AutoWired 根据类型进行注入

2、@Qualifier 根据属性名称注入

3、@Resource 可以根据类型也可以根据名称

4、@Value 根据普通类型注入

public interface UserDao {
    /**
     * 修改
     */
    void update();
}
@Repository
public class UserDaoImpl implements UserDao {

    @Override
    public void update() {
        System.out.println("service add ....");
    }
}
@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("测试 add...");
        userDao.update();
    }
}
 @Test
    public void setUserService(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean5.xml");
        //获取配置创建的对象  这个user是对应的bean的Id
        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.add();
    }

开启组件扫描

<?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">
<!--    开启组件扫描-->
    <context:component-scan base-package="com.ljx"/>
</beans>

使用@Qualifier指定名称注入 防止接口有多个实现类

@Repository(value = "userDao1")
public class UserDaoImpl implements UserDao {

    @Override
    public void update() {
        System.out.println("service add ....");
    }
}
@Service
public class UserService {
    //@Autowired
    @Qualifier(value = "userDao1")
    private UserDao userDao;

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

完全注解开发

1、配置类

@Configuration
@ComponentScan(basePackages = {"com.ljx"})
public class SpringConfig {
    
}
取代了xml注解

2、测试

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

4、AOP

  • 面向切面编程(面向方面编程)

  • 降低耦合度 提高开发

  • 主要就是方便在已有的功能上面添加新的功能 降低代码的耦合度

AOP底层使用的动态代理的方式进行实现的

  • 有接口的动态代码 JDK的动态代理

在这里插入图片描述

  • 没有接口的动态代理 CGLIB动态代理

在这里插入图片描述

1、创建Interface接口和接口的实现类

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

    public void update(String id);
}
public class UserDaoImpl implements UserDao {
    @Override
    public Integer add(int a, int b) {
        return a+b;
    }

    @Override
    public void update(String id) {
        System.out.println(id);
    }
}
public class JDKProxy {
    public static void main(String[] args) {
        UserDaoImpl userDao = new UserDaoImpl();
        // 创建接口实现类的代理对象
        Class[] interfaces = {UserDao.class};
        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,
                new UserDaoProxy(userDao));
        Integer add = dao.add(1, 2);
        System.out.println(add);
    }
}

class UserDaoProxy implements InvocationHandler {
    // 需要把谁的代理对象要把 对象传递过来
    private Object object;
    public UserDaoProxy(Object object){
        this.object=object;
    }

    // 增强逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法之前
        System.out.println("方法之前执行"+method.getName()+"传递的参数是"+ Arrays.toString(args));
        // 被增强的方法执行
        Object res = method.invoke(object, args);
        System.out.println(res);
        // 方法之后
        System.out.println("方法之后执行"+object);
        return res;
    }
}
结果
方法之前执行add传递的参数是[1, 2]
3
方法之后执行com.ljx.UserDaoImpl@355da254
3

AOP专业术语

  • 连接点 类里面那些方法可以被增强 方法被称为连接点

  • 切入点 实际被增强的方法

  • 通知(增强) 实际增强的逻辑部分就是通知(前置 后置 环绕 异常 最终)

  • 切面 将通知应用到切入点的过程

2、AOP的JDK动态代理案例

使用newProxyInstance方法，方法有三个参数 (类加载器、增强方法所在的类 这个类所在的接口 支持多个接口、实现InvocationHandle接口 创建代理对象写增强方法)

3、Spring框架基本使用Aspectj实现AOP操作

一般和Spring框架一起使用实现Aop的功能 一般开发中是基于注解的方式进行使用

4、在项目中引入AOP的依赖

在这里插入图片描述

5、切入点的表达式

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

execution(*com.ljx.dao.BookDao.add(…))

execution(*com.ljx.dao.BookDao. * (…)) BookDao下面的左右方法

execution(*com.ljx.dao. * . * (…)) 下面的所有的方法

6、使用注解的方式实现Aop

在增强类里面创建方法 让不同的代表不同的通知类型

  • 开启注解扫描
  • 使用注解创建User和UserProxy
  • 在增强类上面添加注解@Aspect
  • 在Spring配置文件中开启生成代理对象
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
">
    <context:component-scan base-package="com.ljx"/>
    <!--    开启Aspect生成代理对象  扫描的类上面有@Aspect就生成代理对象-->
    <aop:aspectj-autoproxy/>
</beans>

设置类

// 被增强类
@Component
public class User {
    public void add() {
        System.out.println("add...");
    }
}
@Component
@Aspect
public class UserProxy {
    // 在
    public void before() {
        System.out.println("before");
    }
}

配置不同类型的通知

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

package com.ljx.aopanno;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

// 前置通知 增强类
@Component
@Aspect
public class UserProxy {
    /**
     * 相同切入点抽取
     */
    @Pointcut(value = "execution(* com.ljx.aopanno.User.add(..))")
    public void pointDemo(){

    }

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

    /**
     * 后置通知
     */
    @After(value = "pointDemo()")
    public void after(){
        System.out.println("after");
    }

    /**
     * 返回值之后执行
     */
    @AfterReturning(value = "pointDemo()")
    public void afterReturning(){
        System.out.println("afterReturning");
    }

    /**
     * 出现异常的时候进行通知
     */
    @AfterThrowing(value = "pointDemo()")
    public void afterThrowing(){
        System.out.println("afterThrowing");
    }

    /**
     * 环绕通知
     */
    @Around(value = "pointDemo()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("around前");
        // 执行增强的方法
        proceedingJoinPoint.proceed();
        System.out.println("around后");
        return new Object();
    }
}

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

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

5、事务操作

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

四大特性： ACID

  • 原子性 要么都成功呢要么都失败
  • 一致性 操作前后数据不变
  • 隔离性 多事务操作的时候不会产生影响
  • 持久性 表中数据真正发生改变

事务的操作

基本使用的声明式事务(基于AOP的)

事务的传播行为：

  • 多事务方法直接进行调用,这个过程中事务是如何进行管理的
  • REQUIRED 如果事务在运行 当前方法就在这个事务内运行 否则就启动一个新的事务
  • REQUIRED_NEW 当前的方法必须启动新的事务 并在他自己的事务内运行 如果有事务正在运行 应该将他挂起
  • SUPPORTS 如果事务在运行 当前的方法就在这个事务内运行 否则可以不运行在事务内
  • NOT_SUPPORTS 当前方法不应该在事务中运行 如果有运行的事务 将他挂起
  • MANDATORY 当前的方法必须运行在事务内部 如果没有正在运行的事务 就抛出异常
  • NEVER 当前的方法不应该运行在事务中 如果有运行的事务 就抛出异常
  • NESTED 如果有事务在运行 当前的方法就应该在这个事务的嵌套事内运行 否则就启动一个新的事务

事务隔离级别:

  • 多事务之间不会产生影响 不考虑隔离性产生很多问题 比如
  • 脏读：多个事务之间一个未提交的事务获取了另一个未提交的事务数据

举例：A将数据从1改为2 不进行读取的时候获取的是2 但是这个时候A进行了回滚 那么B读的数据就是脏数据

  • 不可重复读：一个未提交的事务读取了另一个事务修改的数据

A和B都在读取数据 A将数据从100改为200 然后事务进行了提交 但是B在读取数据的时候没有提交数据 导致B一致获取的A提交的数据 导致可能每一次读取的数据都会发生改变

  • 幻读 一个未提交的事务获取了另一个提交事务的数据

设置事务隔离级别

  • READ UNCOMMITTED(读未提交) 脏读 不可重复读 幻读
  • READ COMMINTED(读已提交) 不可重复读 幻读
  • READATABLE READ(可重复度) 幻读
  • SERIALIZABLE(串行化)
NoProblemLi
关注
springboot源码怎么运行二讲解怎么导入运行springboot源码
道阻且长,行则将至 行而不辍,未来可期
02-12 764
前言 结合自己负责的项目进行重构，同时面试他人的前提下，进行学习SPringBoot源码。因为Springboot源码2.3版本之后不在使用pom依赖，所以maven工程导入是打不开的！通过上一篇文章的 讲解前提条件准备完成之后，进行这一篇内容，讲解如何运行SPringBoot源码，我这边本地运行的是SPringBoot版本是2.4版本的源码！ 要满足前提条件： java安装JDK最好jdk8和jdk11版本的环境安装好 maven3.6+ gradle6.9 Int
通俗易懂讲解spring源码
russwest44的博客
04-19 1136
容器与 bean 1) 容器接口 BeanFactory 接口，典型功能有： getBean ApplicationContext 接口，是 BeanFactory 的子接口。它扩展了 BeanFactory 接口的功能，如： 国际化 通配符方式获取一组 Resource 资源 整合 Environment 环境（能通过它获取各种来源的配置信息） 事件发布与监听，实现组件之间的解耦 可以看到，我们课上讲的，都是 BeanFactory 提供的基本功能，ApplicationContext
Spring源码讲解一
weixin_38367817的博客
04-06 280
本文转于，若有侵权可联系删除 前言 Spring 作为现在最优秀的框架之一，被广泛的应用于 Java 项目中，但是大多数人都只知道如何使用，而不知其中的原理。对大多数人来说可能知道如何使用已经...
Spring源码系列：核心概念解析
最新发布
努力的小雨，一个阳光向上的博客不仅仅给你知识更希望带给你快乐
07-23 1377
doGetBean，获取bean的主要逻辑，没有则创建getMergedBeanDefinition，bean定义的合并逻辑，主要是将父类beanfactory中的属性被子类覆盖autowireByName，按照name注入autowireByType，根据类型createBean，创建bean流程，实例化前可以使用BeanPostProcessors后置处理器createBeanInstance，正在创建bean，这边使用到了之前入门讲过的推断构造器实现实例化。
解读 spring源码
qq_16803227的博客
05-07 2009
学习了好久的spring源码，成果总结一下，不一定全对，都是自己研究的 //一、创建一个srping容器，并放置几个核心的 Processor CommonAnnotationProcessor AutowiredAnnotationProcessor AnnotationConfigApplicationContext annotationConfigApplicationContext =...
spring源码详解
weixin_42789698的博客
02-25 256
文章目录spring源码详解一、面试题1、什么是Spring框架，Spring框架主要包含哪些模块2、Spring框架的优势3、IOC和DI是什么？二、Spring源码阅读环境搭建1、前期运行环境与工具准备2、下载源码3、导入IDEA4、一些查看源码的快捷键 spring源码详解 一、面试题 1、什么是Spring框架，Spring框架主要包含哪些模块 Spring是一个开源框架，Spring是一个轻量级的Java开发框架。它是为了解决企业级应用开发的复杂性而创建的。框架的主要优势就是其分层架构，分层架
spring源码解读
学过的东西，讲不出来等于没学。
05-19 2197
容器与 bean 1) 容器接口 BeanFactory 接口，典型功能有： getBean ApplicationContext 接口，是 BeanFactory 的子接口。它扩展了 BeanFactory 接口的功能，如： 国际化 通配符方式获取一组 Resource 资源 整合 Environment 环境（能通过它获取各种来源的配置信息） 事件发布与监听，实现组件之间的解耦 可以看到，我们课上讲的，都是 BeanFactory 提供的基本功能，ApplicationContext
【微服务~原始真解】Spring Cloud —— Eureka Client原码解析(二)
m0_67391377的博客
06-18 114
??这里是【秒懂·云原生】，关注我学习云原生不迷路 ??如果对你有帮助，给博主一个免费的点赞以示鼓励 欢迎各位??点赞??评论收藏【秒懂·云原生】 目前主要更新微服务，一起学习一起进步。主要介绍Spring Cloud —— Eureka Client原码解析(二)为了对Eureka Client的执行原理进行讲解，首先需要对服务发现客户端com.netflix.discover.DiscoveryClient职能以及相关类进行讲解，它负责了与EurekaServer交互的关键逻辑。DiscoveryCli
spring-kafka源码分析-01
kafka_zsxq的博客
12-03 418
前言 对于Java web服务通常都会使用spring-boot作为web基础框架，今天就从spring的角度分析一下kafka是如何注入到spring容器中并且如何使用的。本文主要针对spring-kafka.2.5.5.RELEASE版本进行分析，不涉及kafka-clients原理讲解。 了解Springframework Bean的生命周期： spring容器从全局的角度来看就是管理web系统运行过程中所需要的对象，其中bean的生命周期就是系统运行所依赖对象的 创建过程->初
Spring Boot：基本应用和源码解析
bier_zm的博客
11-13 1860
SpringBoot 基本应用 约定优于配置 约定优于配置（Convention over Configuration），又称按约定编程，是一种软件设计范式。 本质上是说，系统、类库或框架应该假定合理的默认值，而非要求提供不必要的配置。比如说模型中有一个名为 User 的类，那么数据库中对应的表就会默认命名为 User。只有在偏离这一个约定的时候，例如想要将该表命名为 person，才需要写有关这个名字的配置。 比如平时架构师搭建项目就是限制软件开发随便写代码，制定出一套规范，让开发人员按统一的要求
Spring-boot 集成 kakfa 源码分析
Skyline
12-12 1403
SpringBoot 版本：2.0.0.BUILD-SNAPSHOT 类 KafkaAutoConfiguration 主要功能：自动创建各种bean: KafkaTemplate, messageConverter,producerFactory,consumerFactory等。 @Configuration @ConditionalOn
spring源代码中文详解版
10-12
spring源代码的中文解析，让你更加了解spring内部机制，封装类的重用于重写。
Spring源码分析
11-01
Spring源码分析
Spring源码解读
一个有深度的博客
09-08 399
一、beanDefintionReader 是一个抽象定义规范的接口，负责读取配置文件中的信息
Spring源码解读01
水墨@丹青的博客
09-29 318
 此UML为ClassPathResource的资源继承体系图 解读:      InputStreamSource： 提供一个获取输入文件流的方法(getInputStream)。      Resource：继承自InputStreamSource，并抽象出资源描述符的接口，提供对文件进行描述的方法。                       1). boolean exists();...
最近无意中看到一个讲解spring mvc的系列，从源码的角度讲解，特记录下来，供以后反复学习...
weixin_34405925的博客
07-30 542
SpringMVC深度探险（一） —— SpringMVC前传 SpringMVC深度探险（二） —— SpringMVC概览 SpringMVC深度探险（三） —— DispatcherServlet与初始化主线 SpringMVC深度探险（四） —— SpringMVC核心配置文件详解...
Spring 源码解析
qq_27416233的博客
09-18 562
spring 源码解析(1) 初始加载 前言 我很喜欢一句话，年轻时候多学一分，以后就少求别人一次，也送给看博客的各位，下面开始正题 IOC 先谈谈什么是IOC？ 讲真的，这个问题有点老生常谈了，IOC根据官方的语义就是: 控制反转(Inverse Of Control),在 拆分的细致一点: 这个控制指的是什么？反转又是什么意思？ 再次之前我们先来回想一个问题: 不涉及到框架本身我们创建一个对象的方法有哪些？ 1. new ClassName(); ---> 直接new对象的方式 2.
Spring源码解析
Hypergroup的博客
11-19 146
第一个方法:加载配置文件init(ServletConfig config)    ①获取配置文件的名字     config.getInitParameter("") ----&gt; 对应web.xml文件中的&lt;servlet&gt;中的&lt;init-param&gt;     param-value = config.getInitParameter("param-name"...
springioc原码
03-29
抱歉，由于您的问题不够明确，我无法为您提供准确的答案。Spring IOC的原码非常庞大，包含了许多模块和类，如果您需要查看Spring IOC的原码，建议您先确定您需要查看哪个具体的部分或类，并在官方文档或代码库中查找相关资料。如果您有更具体的问题或需求，请提供更详细的信息，我将尽力为您提供帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值