Spring深入学习

1 Bean创建的生命周期

Spring bean是Spring运行时管理的对象。Spring Bean的生命周期指的是Bean从创建到初始化再到销毁的过程,这个过程由IOC容器管理。

IOC即控制反转,是面向对象编程中的一种设计原则,通过依赖注入(DI)、依赖查找的方式实现对象之间的松耦合关系。

BeanFactory为IoC容器,ApplicationContext为应用上下文,ApplicationContext容器包括BeanFactory容器的所有功能。

1)创建bean的三种方式

  1. 基于XML配置文件
  2. 基于注解,@Component、 @Repository、@Service、@Controller;@Component可以代替@Repository、@Service、@Controller。
  3. 基于Java类的bean定义,需要提供setter方法
    @Bean
    public Student student(){
        return new Student();;
    }


    public class Student{
        private String name;
  
        public void SetName(String name){
            this.name = name;
        }
    }

 2)bean对象

 Spring深入学习_第1张图片

Spring深入学习_第2张图片

对象不一定是bean,bean一定是对象,bean对象都放在一个MAP里。 

获取对象的方式可以使用构造方法去创建对象,上面的UserService就存在一个默认的构造方法。(如果程序中没有显式定义任何构造方法,那么java语言将自动提供一个隐含的默认构造方法。

spring扫描到@Component等注解时,就会认为这是定义的bean,就会使用此类构造方法获取对象。然后Spring去检查哪些对象存在@Autowired,就给自动进行依赖注入,进行赋值。

UserServie.class--->构造方法--->普通对象--->依赖注入--->放入Map

spring会继续去检查哪些方法存在@PostConstruct方法,然后主动执行方法里的内容。 

Spring深入学习_第3张图片

实现逻辑如下:

Spring深入学习_第4张图片

当然也可以实现InitializingBean接口,用写afterPropertiesSet()方式实现

Spring深入学习_第5张图片

((InitializingBean)对象).afterPropertiesSet(); 

UserServie.class--->推断构造方法--->普通对象--->依赖注入--->初始化前(@PostConstruct)--->初始化(InitializingBean)--->初始化后(AOP)--->代理对象--->放入Map

推断构造方法:

@Service
public class UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

写了无参构造,则默认使用无参构造依赖注入;

不写无参构造,写多个有参构造,会报错No Default Construct;必须使用@Autowired指定默认是是哪个;

不写无参构造,只写一个有参构造,则会直接使用这个有参构造进行依赖注入;

依赖注入完成属性赋值,spring会依据入参的类型、名字去spring IOC容器里的Bean MAP里寻找bean对象。

Spring深入学习_第6张图片

1.1 依赖注入

在Java中,DI的实现方式主要有以下几种:

● 构造器注入
● Setter方法注入
● 接口注入
● 注解注入

1)构造器注入(spring框架中在构造方法上添加@Autowired注解)

@Component 标准一个普通的spring Bean类; @Repository标注一个DAO组件类; @Service标注一个业务逻辑组件类。 @Component可以代替@Repository、@Service、@Controller,因为这三个注解是被@Component标注的。

@Service
public class UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUserById(int id) {
        return userRepository.getUserById(id);
    }
}

2)setter方法注入(在setter方法上添加@Autowired注解)

@Service
public class UserService {
    private UserRepository userRepository;

    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUserById(int id) {
        return userRepository.getUserById(id);
    }
}

3)接口注入

@Service
public class UserService {
    private UserRepository userRepository;

    @Autowired
    public void setUserRepositorySetter(UserRepositorySetter userRepositorySetter) {
        userRepositorySetter.setUserRepository(userRepository);
    }

    public User getUserById(int id) {
        return userRepository.getUserById(id);
    }
}

实现对应的接口

public interface UserRepositorySetter {
    void setUserRepository(UserRepository userRepository);
}

@Repository
public class UserRepositoryImpl implements UserRepository, UserRepositorySetter {
    @Override
    public User getUserById(int id) {
        // 实现代码
    }

    @Override
    public void setUserRepository(UserRepository userRepository) {
        // 实现代码
    }
}

4)注解注入

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User getUserById(int id) {
        return userRepository.getUserById(id);
    }
}

依赖注入如何寻找是哪个 userRepository?过程如下,从by type 到 by name:

Spring深入学习_第7张图片

Spring深入学习_第8张图片

Spring深入学习_第9张图片

1.2 AOP

认识AOP

AOP 是 Aspect Oriented Programming 的缩写,译为面向切向编程。

设计一个日志打印模块: 

  • 按 OOP 思想,我们会设计一个打印日志 LogUtils 类,然后在需要打印的地方引用即可。
  • 按AOP思想,声明哪些地方需要打印日志,这个地方就是一个切面,AOP 会在适当的时机为你把打印语句插进切面。

AOP实现的关键在于AOP框架自动创建的AOP代理,以AspectJ为代表的静态代理,以Spring AOP为代表的动态代理。Spring AOP中的动态代理主要有两种方式:JDK动态代理和CGLIB动态代理。

Spring AOP通过在代理类中包裹切面,Spring在运行期把切面织入到Spring管理的bean中。代理类封装了目标类,并拦截被通知方法的调用,再把调用转发给真正的目标bean(目标对象)。

Spring深入学习_第10张图片

AOP实现技术由APT、AspetJ等,如下:

Spring深入学习_第11张图片

Spring深入学习_第12张图片

1)横切关注点

跨越应用程序多个模块的方法或功能,如日志、安全、缓存、事务等等。

2)连接点

连接点是在应用执行中能够插入切面的一个点。即程序执行过程中能够应用通知的所有点。

3)通知

切面的工作被称为通知,Spring切面可以应用5种类型的通知:

  • 前置通知(Before):在目标方法被调用之前调用通知功能。
  • 后置通知(After):在目标方法完成之后调用通知,此时不会关心方法的输出是什么。
  • 返回通知(After-returning):在目标方法成功执行之后调用通知。
  • 异常通知(After-throwing)):在目标方法抛出异常后调用通知。
  • 环绕通知(Around) :通知包裹了被通知的方法,在被通知的方法调用之前和调用之后执行自定义的行为。

1.3 SpringBoot AOP

Spring深入学习_第13张图片

orderService为空? 

Spring深入学习_第14张图片

进入test之前,orderServcie是有值的!

1)Spring首先要判断这个对象要不要执行AOP

2)生成一个子类代理类,继承UserService,重写UserService里的test方法

3)子类代理类(代理对象)执行test方法时,先执行切面逻辑,然后执行业务逻辑

4)执行 代理对象.target.test()方法

        代理对象.target对象 = 被代理对象 = 普通对象 = 已经经过了依赖注入 = 对象已经属性有值;

        但是代理对象没有依赖注入,没有值;他只是为了执行切面逻辑,所以不需要必须去用对象的属性。

Spring深入学习_第15张图片

Spring深入学习_第16张图片

切面逻辑中可以通过获取这个target对象,来获取普通对象

Spring深入学习_第17张图片

AOP基本使用: 

依赖

    org.springframework.boot
    spring-boot-starter-aop


代码
@Aspect  // 使用@Aspect注解声明一个切面
@Component
public class SysLogAspect {

    @Autowired
    private SysLogService sysLogService;

    @Pointcut("@annotation(com.lmlsj.SysLog)")
    public void logPointCut() {}


    @Before("execution(* com.lmlsj.SysLog.*(..))")
    public void before() {
        System.out.println("MyAspect: 前置增强.....");
    }
}

配置
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

}

正常流程:【环绕通知-前】-> 【前置通知】-> 【返回通知】-> 【后置通知】->【环绕通知-后】。 

2 事物

1)事物执行逻辑

Spring深入学习_第18张图片

Spring深入学习_第19张图片

Spring深入学习_第20张图片

2)普通对象调用,事物失效

Spring深入学习_第21张图片

这里a()方法是普通对象的,直接执行a()里面的语句,不会去走切面逻辑判断是否有@Transactional注解,事物失效。 

3)代理对象调用才会去走切面逻辑

自己注入自己,使用代理对象实现事物正常执行

Spring深入学习_第22张图片

4)@Configuration

加上@Configuration后,Appconfig就是代理对象,才能保证下图两处的dataSource()是同一个对象,才能执行事务。

Spring深入学习_第23张图片

3 扫描

Spring扫描首先Spring根据注解去寻找bean类,非懒加载的bean在Spring容器启动时就创建好,懒加载的bean是用到时再创建。如何寻找注解的实现思路:

1)反射方式:AA.class.isAnnotationPresent(Component.class)

2)ASM技术(Spring使用):编辑CLASS字节码

扫描类的寻找:

AnnotationConfigApplicationContext.java

Spring深入学习_第24张图片

Spring深入学习_第25张图片

Spring深入学习_第26张图片

Spring深入学习_第27张图片

Spring深入学习_第28张图片

Spring深入学习_第29张图片

Spring深入学习_第30张图片

Spring深入学习_第31张图片

1)处理配置类

(1)判断Component注解

ConfigurationClassParser.java  doProcessConfigurationClass(*)

(2)检查是不是配置类的地方

Spring深入学习_第32张图片

Spring深入学习_第33张图片

Spring深入学习_第34张图片

Spring深入学习_第35张图片

2)ComponentScan

parse解析得到BeanDefinition集合,然后去遍历BeanDefinition这些对象是不是有什么注解、配置

Spring深入学习_第36张图片

 3)parse属性解析过程

ComponentScanAnnotationParser类

Spring深入学习_第37张图片

this.registry是Spring IOC容器

(1) useDefaultFilters属性,注册一些默认的过滤器

Spring深入学习_第38张图片

Spring深入学习_第39张图片

(2)ComponentScan的nameGenerator属性

generatorClass是nameGenerator属性的管理,没有设置该属性就使用默认值。

补充:可以根据@Component的value设置bean的名字,没有设置就根据类名进行设置。

Spring深入学习_第40张图片

Spring深入学习_第41张图片

前两个字符都是大写,就直接返回;不符合就将第一个字符,设置为小写。

Spring深入学习_第42张图片

(3)scopeProxy属性设置

Spring深入学习_第43张图片

作用域在类上设置,在收到请求时再创建bean

Spring深入学习_第44张图片

同时可以指定代理对象的生成方式

Spring深入学习_第45张图片

(4)resourcePattern、includeFilters、excludeFilters属性

Spring深入学习_第46张图片

excludeFilters可以设置某个类不是一个bean,type = FilterType.ASSIGNABLE_TYPE是根据类class来过滤

@ComponentScan(value = "com.lmlsj", excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {MyService.class})})

(5)懒加载

Spring深入学习_第47张图片

(6)扫描路径属性

根据属性值配置扫描路径,或者根据@ComponentScan注解配置扫描路径

Spring深入学习_第48张图片

排除器,排除已经设置成bean的类 

Spring深入学习_第49张图片

最后就是doScan真正的扫描开始。

4)doScan扫描

Spring深入学习_第50张图片

扫描包路径

 public Set findCandidateComponents(String basePackage) {
        return this.componentsIndex != null && this.indexSupportsIncludeFilters() 
        ? 
        this.addCandidateComponentsFromIndex(this.componentsIndex, basePackage) : 
        this.scanCandidateComponents(basePackage);
    }

Spring深入学习_第51张图片

Spring深入学习_第52张图片

检查是否在过滤器里

Spring深入学习_第53张图片

4 Spring启动demo

Spring深入学习_第54张图片

1)SpringApplicationContex

public class SpringApplicationContext {

    private Class configClass;
    private Map beanDefinationMap = new HashMap<>();
    private Map singletonObjects = new HashMap<>();  //单例池
    private List beanPostProcessorList = new ArrayList<>();

    public SpringApplicationContext(Class configClass) {
        this.configClass = configClass;
        scan(configClass);              //解析传进来的配置类,生成beanDefination
        preInstantiateSingletons();     //单例bean初始化
    }

    private void preInstantiateSingletons() {
        for(Map.Entry entry : beanDefinationMap.entrySet()){
            BeanDefination beanDefination = entry.getValue();
            if(beanDefination.getScope().equals("singleton")){
                Object bean = createBean(entry.getKey(), beanDefination);
                singletonObjects.put(entry.getKey(), bean);     //单例bean
            }
        }
    }

    public Object createBean(String beanName, BeanDefination beanDefination){
        Class clazz = beanDefination.getClazz();
        Object instance = null;
        try {
            // 1 对象实例化
            instance = clazz.newInstance();

            // 2 依赖注入 属性赋值
            for(Field field : clazz.getDeclaredFields()){
                if(field.isAnnotationPresent(LmAutowired.class)){
                    String name = field.getName();  // field.getType()  ,by name/ by type
                    Object bean = getBean(name);
                    field.setAccessible(true);
                    field.set(instance,bean);
                }
            }

            // 4 初始化前
            for (BeanPostProcess beanPostProcess : beanPostProcessorList) {
               instance =  beanPostProcess.postProcessBeforeInitialization(instance,beanName);
            }

            // 3 spring初始化数值
            if(instance instanceof InitializingBean){
                try {
                    ((InitializingBean)instance).afterPropertiesSet();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            // 5 初始化后
            for (BeanPostProcess beanPostProcess : beanPostProcessorList) {
               instance =  beanPostProcess.postProcessAfterInitialization(instance,beanName);
            }

        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return instance;
    }

    public void scan(Class configClass){
        // 1 解析配置类
        if(configClass.isAnnotationPresent(LmComponentScan.class)){
            LmComponentScan componentScan = (LmComponentScan)configClass.getAnnotation(LmComponentScan.class);
            String path = componentScan.value();
            System.out.println("配置路径: " + path);
            path = path.replace(".","/");

            //2 扫描配置路径下有LmComponent注解的类
            ClassLoader classLoader = SpringApplicationContext.class.getClassLoader();  //app
            URL resource = classLoader.getResource(path);

            File file = new File(resource.getFile()); //获取对应文件夹
            File[] files = file.listFiles();//文件夹下所有的文件

            for (File f : files) {
                String fileName = f.getAbsolutePath();
                if(fileName.endsWith(".class")){
                    String className = fileName.substring(fileName.indexOf("com"),fileName.indexOf(".class"));
                    className = className.replace("/",".");
                    try {
                        Class clazz = classLoader.loadClass(className);
                        //spring是使用ASM去解析字节码文件的,这里简单实现一下
                        if(clazz.isAnnotationPresent(LmComponent.class)){

                            //beanPostProcessorList初始化
                            if(BeanPostProcess.class.isAssignableFrom(clazz)){
                                try {
                                    BeanPostProcess beanPostProcess = (BeanPostProcess) clazz.newInstance();
                                    beanPostProcessorList.add(beanPostProcess);
                                } catch (InstantiationException e) {
                                    e.printStackTrace();
                                } catch (IllegalAccessException e) {
                                    e.printStackTrace();
                                }
                            }

                            LmComponent annotation = (LmComponent) clazz.getAnnotation(LmComponent.class);
                            String beanName = annotation.value();
                            //3 生成beanDefination对象
                            BeanDefination beanDefination = new BeanDefination();

                            beanDefination.setClazz(clazz);

                            if(clazz.isAnnotationPresent(Scope.class)){
                                Scope scope = (Scope) clazz.getAnnotation(Scope.class);
                                beanDefination.setScope(scope.value());
                            }else{
                                beanDefination.setScope("singleton");
                            }

                            beanDefinationMap.put(beanName,beanDefination);
                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
                }
            }
        }else {
            System.out.println("没有LmComponentScan注解");
        }
    }

    public Object getBean(String beanName){
        //1 判断是否已存在bean
        if(beanDefinationMap.containsKey(beanName)){
            BeanDefination beanDefination = beanDefinationMap.get(beanName);
            //2 判断是不是单例bean
            if(beanDefination.getScope().equals("singleton")){
                Object o = singletonObjects.get(beanName);
                return o;
            }else{
                //多例bean
                Object bean = createBean(beanName,beanDefination);
                return bean;
            }
        }else {
            System.out.println("没有找到" + beanName);
            throw new NullPointerException();
        }
    }

}

2)BeanDefination

public class BeanDefination {

    private Class clazz;
    private String scope;

    public Class getClazz() {
        return clazz;
    }

    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }
    
}

3)BeanPostProcess

public interface BeanPostProcess {

    Object postProcessBeforeInitialization(Object bean,String beanName);

    Object postProcessAfterInitialization(Object bean,String beanName);
}

4)InitializingBean

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

5)注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface LmAutowired {

    String value() default ""; //属性
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface LmComponent {

    String value() default ""; //属性
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface LmComponentScan {

    String value() default ""; //属性
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Scope {
    String value() default ""; //属性
}

6)测试类

public class Main {

    public static void main(String[] args){
        //用spring 包里自己写的代码
        SpringApplicationContext springApplicationContext = new SpringApplicationContext(AppConfig.class);

        //多例bean
        UserService userService =  (UserService)springApplicationContext.getBean("userService");
        UserService userService2 =  (UserService)springApplicationContext.getBean("userService");
        UserService userService3 =  (UserService)springApplicationContext.getBean("userService");
        System.out.println(userService);
        System.out.println(userService2);
        System.out.println(userService3);

        userService.test();

        System.out.println("_____________________");
        //单例bean
        OrderService orderService = (OrderService)springApplicationContext.getBean("orderService");
        OrderService orderService2 = (OrderService)springApplicationContext.getBean("orderService");
        OrderService orderService3 = (OrderService)springApplicationContext.getBean("orderService");
        System.out.println(orderService);
        System.out.println(orderService2);
        System.out.println(orderService3);
    }
}

7)BeanPostProcesorImpl

@LmComponent
public class BeanPostProcesorImpl implements BeanPostProcess {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if(beanName.equals("orderService")){
            System.out.println("初始化之前");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        //代理AOP在此实现
        return bean;
    }
}

8)AppConfig

@LmComponentScan("com.lmlsj.test")
public class AppConfig {
}

9)其他类

@LmComponent("orderService")
public class OrderService {
}

@LmComponent("userDao")
public class UserDao {
}

@LmComponent("userService")
@Scope("prototype")
public class UserService implements InitializingBean {

    @LmAutowired
    private UserDao userDao;

    private User defaultUser;

    public void test(){
        System.out.println(userDao);
        System.out.println(defaultUser.getName() + ":" + defaultUser.getPass());
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        defaultUser = new User("default","123456");
    }
}


10)测试结果

Spring深入学习_第55张图片

你可能感兴趣的:(spring,java)