本文共 9812 字，大约阅读时间需要 32 分钟。

IOC

基于注解

1、什么是注解

（1）注解是代码特殊标记，格式： @注解名称(属性名称=属性值, 属性名称=属性值..)

（2）使用注解，注解作用在类上面，方法上面，属性上面

（3）使用注解目的：简化 xml 配置

2、 Spring 针对 Bean 管理中创建对象提供注解（下面四个注解功能是一样的，都可以用来创建 bean 实例）

（1） @Component

（2） @Service

（3） @Controller

（4） @Repository

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

（1）引入依赖

（2）配置组件扫描

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

package com.study.spring5.service;import com.study.spring5.dao.UserDao;import org.springframework.stereotype.Component;import org.springframework.stereotype.Service;/** * //在注解里面 value 属性值可以省略不写， * 默认值是类名称，首字母小写 * UserService -- userServi * * @author Tristen Li * @create 2020-09-08 9:51 */@Servicepublic class UserService {       public void add() {        System.out.println("UserService add...");    }}

4.开启组件扫描细节配置

（1）配置不使用默认的过滤器，仅扫描某些内容

（2）配置使用默认的过滤器，但不扫描某些类

5.基于注解方式，实现属性注入

（1） @Autowired：根据属性类型进行自动装配

第一步 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

package com.study.spring5.service;import com.study.spring5.dao.UserDao;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Value;import org.springframework.stereotype.Service;/** * * @author Tristen Li * @create 2020-09-08 9:51 */@Servicepublic class UserService {    @Autowired    private UserDao userDao;    public void add() {        userDao.add();        System.out.println("UserService add...");    }}

（2） @Qualifier：根据名称进行注入，和上面@Autowired 一起使用（当一个接口存在多个实现类时使用）

package com.study.spring5.service;import com.study.spring5.dao.UserDao;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.beans.factory.annotation.Value;import org.springframework.stereotype.Service;/** * * @author Tristen Li * @create 2020-09-08 9:51 */@Servicepublic class UserService {    @Autowired    @Qualifier(value = "userDaoImpl")    private UserDao userDao;    public void add() {        userDao.add();        System.out.println("UserService add...");    }}

（3） @Resource：可以根据类型注入，可以根据名称注入

package com.study.spring5.service;import com.study.spring5.dao.UserDao;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.beans.factory.annotation.Value;import org.springframework.stereotype.Service;import javax.annotation.Resource;/** * * @author Tristen Li * @create 2020-09-08 9:51 */@Servicepublic class UserService {    @Resource(name = "userDaoImpl")    private UserDao userDao;    public void add() {        userDao.add();        System.out.println("UserService add...");    }}

（4） @Value：注入普通类型属性 

package com.study.spring5.service;import com.study.spring5.dao.UserDao;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.beans.factory.annotation.Value;import org.springframework.stereotype.Service;/** * @author Tristen Li * @create 2020-09-08 9:51 */@Servicepublic class UserService {    @Value(value = "asd")    private String name;    @Autowired    @Qualifier(value = "userDaoImpl")    private UserDao userDao;    public void add() {        userDao.add();        System.out.println("UserService add...name=" + name);    }}

6.完全注解开发

（1）创建配置类，替代xml配置文件

package com.study.spring5.config;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;/** * @author Tristen Li * @create 2020-09-08 10:16 */@Configuration@ComponentScan(basePackages = {"com.study"})public class SpringConfig {}

（2）编写测试类

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

AOP

相关概念

1、什么是 AOP

（1）面向切面编程（方面）， 利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

（2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能

（3）使用登录例子说明 AOP

底层原理

1、 AOP 底层使用动态代理

（1）有两种情况动态代理

第一种 有接口情况，使用 JDK 动态代理

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

第二种 没有接口情况，使用 CGLIB 动态代理

⚫ 创建子类的代理对象，增强类的方法

JDK 动态代理

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

（1）调用 newProxyInstance 方法

方法有三个参数：

第一参数，类加载器

第二参数，增强方法所在的类，这个类实现的接口，支持多个接口

第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

2、编写 JDK 动态代理代码

1）创建接口，定义方

package com.study.spring5;/** * @author Tristen Li * @create 2020-09-08 10:56 */public interface UserDao {    public int add(int a, int b);    public String update(String id);}

（2）创建接口实现类

package com.study.spring5;/** * @author Tristen Li * @create 2020-09-08 11:04 */public class UserDaoImpl implements UserDao {    @Override    public int add(int a, int b) {        System.out.println("add.....");        return a + b;    }    @Override    public String update(String id) {        System.out.println("Update.....");        return id;    }}

（3）使用Proxy类创建接口代理对象

package com.study.spring5;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.util.Arrays;/** * @author Tristen Li * @create 2020-09-08 11:09 */public class JDKProxy {    public static void main(String[] args) {        Class[] interfaces = {UserDao.class};        UserDao userDao = new UserDaoImpl();        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));        System.out.println(dao.add(1, 2));        System.out.println(dao.update("ABC"));    }}/** * 代理对象实现类 */class UserDaoProxy implements InvocationHandler {    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;    }}

相关术语

1.连接点

2.切入点

3.通知（增强）

4.切面

AOP实现

1、 Spring 框架一般都是基于 AspectJ 实现 AOP 操作

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

2、基于 AspectJ 实现 AOP 操作

（1）基于 xml 配置文件实现

（2）基于注解方式实现（使用）

3、在项目工程里面引入 AOP 相关依赖

4、切入点表达式

（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强

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

举例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强

execution(* com.study.dao.BookDao.add(..))

举例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强

execution(* com.study.dao.BookDao.* (..))

举例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强

execution(* com.study.dao.*.* (..))

AspectJ 注解

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

package com.study.spring5.aopanno;/** * 被增强类 * * @author Tristen Li * @create 2020-09-08 11:52 */public class User {    public void add() {        System.out.println("add...");    }}

2.创建增强类

（1）在增强类里面，创建方法，让不同方法代表不同通知类型

package com.study.spring5.aopanno;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.*;import org.springframework.stereotype.Component;/** * 增强类 * * @author Tristen Li * @create 2020-09-08 11:52 */public class UserProxy {    /**     * 前置通知     */    public void before() {        System.out.println("before...");    }}

（2）使用注解创建User和UserProxy对象

（3）在增强类上面添加注解@Aspect

3.进行通知的配置

4.配置不同类型的通知

package com.study.spring5.aopanno;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.*;import org.springframework.stereotype.Component;/** * 增强类 * * @author Tristen Li * @create 2020-09-08 11:52 */@Aspect@Componentpublic class UserProxy {    /**     * 前置通知     */    @Before(value = "execution(* com.study.spring5.aopanno.User.add(..))")    public void before() {        System.out.println("before...");    }    @After(value = "execution(* com.study.spring5.aopanno.User.add(..))")    public void after(){        System.out.println("after...");    }    @AfterReturning(value = "execution(* com.study.spring5.aopanno.User.add(..))")    public void afterReturning(){        System.out.println("afterReturning...");    }    @AfterThrowing(value = "execution(* com.study.spring5.aopanno.User.add(..))")    public void afterThrowing(){        System.out.println("afterThrowing...");    }    @Around(value = "execution(* com.study.spring5.aopanno.User.add(..))")    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {        System.out.println("环绕之前...");        proceedingJoinPoint.proceed();        System.out.println("环绕之后...");    }}

5.相同切入点抽取

package com.study.spring5.aopanno;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.*;import org.springframework.stereotype.Component;/** * 增强类 * * @author Tristen Li * @create 2020-09-08 11:52 */@Aspect@Componentpublic class UserProxy {    /**     * 向上抽取切入点     */    @Pointcut(value = "execution(* com.study.spring5.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 void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {        System.out.println("环绕之前...");        proceedingJoinPoint.proceed();        System.out.println("环绕之后...");    }}

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

（1）在增强类上面添加注解@Order（数字类型值），数字类型值越小优先级越高

7.完全使用注解开发

xml实现AOP

1.创建两个类

2.在spring配置文件中已创建两个对象

3.在spring配置文件中配置切入点

转载地址：http://zfirn.baihongyu.com/