Spring之IOC、AOP及基本使用

概述

Spring是轻量级的开源的JavaEE框架,可以解决企业应用开发的复杂性,有两个核心部分:IOC和Aop。

• IOC:控制反转,把创建对象过程交给spring进行。

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

特点

• 方便解耦，简化开发

• AOP编程支持

• 方便程序测试

• 方便和其他框架进行整合

• 方便进行事务操作

• 降低API开发难度

相关依赖

        
            org.springframework
            spring-beans
            5.2.6.RELEASE
        
        
            org.springframework
            spring-context
            5.2.6.RELEASE
        
        
            org.springframework
            spring-core
            5.2.6.RELEASE
        
        
            org.springframework
            spring-expression
            5.2.6.RELEASE
        
        
            commons-logging
            commons-logging
            1.1.1
        
    

spring配置文件

基本使用

package com.company.testdemo;

import com.company.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5 {

    @Test
    public void testAdd(){
//        1.加载spring配置文件
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
//        2.获取配置创建的对象
        User user = context.getBean("user", User.class);
        System.out.println(user);
        user.add();
    }
}

IOC

控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理，使用IOC目的是为了降低耦合度。

底层原理

xml解析、工厂模式、反射

IOC 接口(BeanFactory)

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

Spring提供IOC容器实现两种方式:(两个接口)

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

特点:加载配置文件时候不会创建对象，在获取对象(或者使用对象)才去创建对象

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

特点:加载配置文件时候就会把在配置文件对象进行创建

ApplicationContext接口有实现类

• FileSystemXmlApplicationContext

• configLocation:要写上配置文件在系统盘(某个盘)里的路径

• ClassPathXmlApplicationContext

• configLocation:要写上类路径

IOC操作Bean管理

Bean管理指的是两个操作Spring 创建对象、Spring 注入属性。Bean管理操作有两种方式，基于xml配置文件方式实现、基于注解方式实现。

基于xml方式

基于xml方式创建对象

• 在Spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建

• 在bean标签有很多属性，介绍常用的属性

• id属性:唯一标识

• class属性:类全路径(包和类路径)

• 创建对象时候，默认也是执行无参构造方法

基于xml方式注入属性

DI:依赖注入,就是注入属性

DI是IOC一种具体实现，表示依赖注入，注入属性是在创建对象的基础之上进行完成

• 使用set方法进行注入

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

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

• 使用有参数构造方法进行注入

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

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

• p名称空间注入

• 使用p名称空间注入，可以简化基于xml配置方式,添加p名称空间在配置文件中

• 进行属性注入，在bean标签里面进行操作

xml注入其他类型属性

字面量

1. null值

2. 属性值包含特殊符号

    
        
            >]]>
        

注入属性-外部bean

1. 创建两个类service类和dao类

2. 在service调用dao里面的方法

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

注入属性-内部bean

注入属性-级联赋值

xml方式注入集合属性

1. 注入数组类型属性

2. 注入List集合类型属性

3. 注入Map集合类型属性

    
        
        
            
                java课程
                数据库课程
            
        
        
        
            
                张三
                李四
            
        
        
        
            
        
        
        
            
                MySQL
                redis
            
        
    

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

• 把集合注入部分提取出来

• 在Spring配置文件中引入名称空间util

• 使用util标签完成list集合注入提取

       
    
        降龙十八掌
        九阳神功
    

        
    
        
    

FactoryBean

1. Spring有两种类型bean,一种普通bean,另一种工厂bean(FactoryBean)

2. 普通bean:在配置文件中定义bean类型就是返回类型

3. 工厂bean:在配置文件中定义bean类型可以和返回类型不一样

bean 作用域

1. 在Spring里面，可以设置bean实例是单实例还是多实例

2. 在Spring里面，默认情况下，bean是单实例对象

如何设置单实例还是多实例?

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

2. scope属性值

1. singleton,表示单实例对象,默认值

2. prototype,表示是多实例对象

singleton和prototype区别

3. singleton表示单实例，prototype表示多实例

4. 设置scope值singleton时候，加载spring配置文件就会创建一个单实例对象

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

bean 生命周期

1. 生命周期

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

2. bean生命周期

1. 通过构造器创建bean实例(无参数构造)

2. 为bean的属性设置值和对其他bean引用(调用set方法)

3. 调用bean初始化的方法(需要进行配置初始化方法)

4. bean可以使用了(对象获取到了)

5. 当容器关闭时候，调用bean的销毁的方法(需要进行配置销毁的方法)

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

3. 通过构造器创建bean实例(无参数构造)

4. 为bean的属性设置值和对其他bean引用(调用set方法)

5. 把bean实例传递bean前置处理器的方法postProcessBeforeInitialization

6. 调用bean初始化的方法(需要进行配置初始化方法)

7. 把bean实例传递bean后置处理器的方法postProcessAfterInitialization

8. bean可以使用了(对象获取到了)

9. 当容器关闭时候，调用bean的销毁的方法(需要进行配置销毁的方法)

添加后置处理器

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

}

xml 自动装配

自动装配是指根据指定装配规则(属性名称或者属性类型)，Spring自动将匹配的属性值进行注入

• 根据属性名称自动注入

• 根据属性类型自动注入

引入外部属性文件

配置德鲁伊连接池

基于注解方式

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

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

• @Component

• @Service

• @Controller

• @repository

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

基于注解方式实现对象创建

开启组件扫描

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

//在注解里面value属性值可以省略不写
//默认值是类名称，首字母小写
//  UserService -- userService
@Component(value = "userService")  //
public class UserService {

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

开启组件扫描细节配置

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

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

//    定义dao类型的属性
//    不需要添加set方法
//    添加注入属性注解
    @Autowired
    private UserDao userDao;

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

• 这个@Qualifier注解的使用，和上面@Autowired一起使用

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

• Resource是Javax包里面的

• @Value：注入普通类型属性

AOP

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

底层原理

AOP底层使用动态代理

• 有接口的情况,使用JDK动态代理

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

• 没有接口情况，使用CGLIB动态代理

• 创建子类的动态对象，增强类的方法

JDK动态代理

使用JDK动态代理，使用Proxy类里面的方法创建代理对象

java.lang.reflect.Proxy

newProxyInstance方法

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

//创建代理对象代码
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;
    }
}

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces={UserDao.class};
//        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
//            @Override
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                return null;
//            }
//        });
        UserDaoImpl userDao=new UserDaoImpl();
        UserDao dao=(UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int result = dao.add(1, 2);
        System.out.println("result"+result);
    }
}

AOP(术语)

• 连接点（Jointpoint）：表示需要在程序中插入横切关注点的扩展点，连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等等，Spring只支持方法执行连接点，在AOP中表示为在哪里干；

• 切入点（Pointcut）： 选择一组相关连接点的模式，即可以认为连接点的集合，Spring支持perl5正则表达式和AspectJ切入点模式，Spring默认使用AspectJ语法，在AOP中表示为在哪里干的集合；

• 通知（Advice）：在连接点上执行的行为，通知提供了在AOP中需要在切入点所选择的连接点处进行扩展现有行为的手段；包括前置通知（before advice）、后置通知(after advice)、环绕通知（around advice），在Spring中通过代理模式实现AOP，并通过拦截器模式以环绕连接点的拦截器链织入通知；在AOP中表示为干什么；

• 方面/切面（Aspect）：横切关注点的模块化，比如上边提到的日志组件。可以认为是通知、引入和切入点的组合；在Spring中可以使用Schema和@AspectJ方式进行组织实现；在AOP中表示为在哪干和干什么集合；

AOP相关操作

• Spring框架一般基于AspectJ实现AOP操作

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

• 基于AspectJ实现AOP操作

• 基于xml配置文件实现

• 基于注解方式实现(使用)

• 切入点表达式

• 切入点表达式的作用，知道对哪个类型里面的哪个方法进行增强

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

AOP操作(@Aspect注解)

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

在spring配置文件中开启生成代理对象

package com.xxx.spring5.aopanno;

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

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

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.xxx.spring5.aopanno.User.add(..))")
    public void before(){
        System.out.println("before.......");
    }
    //后置通知(返回通知)
    @AfterReturning(value = "execution(* com.xxx.spring5.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning.....");
    }


    //最终通知
    @After(value = "execution(* com.xxx.spring5.aopanno.User.add(..))")
    public void after(){
        System.out.println("afterg.....");
    }

    //异常通知
    @AfterThrowing(value = "execution(* com.xxx.spring5.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing.....");
    }

    //环绕通知
    @Around(value = "execution(* com.xxx.spring5.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前.......");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后.......");
    }
}

相同切入点抽取

    //相同切入点抽取
    @Pointcut(value ="execution(* com.xxx.spring5.aopanno.User.add(..))")
    public void pointdemo(){

    }

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("before.......");
    }

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

完全使用注解开发

@Configuration
@ComponentScan(basePackages = {"com.xxx"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

AOP操作(AspectJ配置文件)

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