spring5框架——IOC（基于注解）&AOP（二）

于 2020-09-08 16:37:24 发布
阅读量186 收藏
点赞数
分类专栏： JavaEE框架 文章标签： spring IOC AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41819988/article/details/108469409
版权

IOC

基于注解

1、什么是注解

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

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

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

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

（1） @Component

（2） @Service

（3） @Controller

（4） @Repository

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

（1）引入依赖

（2）配置组件扫描

 <!--开启组件扫描
    1 如果扫描多个包，多个包使用逗号隔开
    2 扫描包上层目录
 -->
<context:component-scan base-package="com.study"></context:component-scan>

（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
 */
@Service
public class UserService {
       public void add() {
        System.out.println("UserService add...");
    }
}

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

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

 <!--示例 1
        use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
        context:include-filter ，设置扫描哪些内容
    -->
    <context:component-scan base-package="com.study.spring5" use-defaultfilters="false">
        <context:include-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

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

    <!--示例 2
        下面配置扫描包所有内容
         context:exclude-filter： 设置哪些内容不进行扫描
    -->
    <context:component-scan base-package="com.study.spring5">
        <context:exclude-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

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
 */
@Service
public 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
 */
@Service
public 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
 */
@Service
public 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
 */
@Service
public 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.进行通知的配置

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

    <!--开启注解扫描-->
    <context:component-scan base-package="com.study.spring5.aopanno"></context:component-scan>

    <!--开启Aspectj生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

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
@Component
public 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
@Component
public 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配置文件中已创建两个对象

<!--创建对象-->
<bean id="book" class="com.study.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.study.spring5.aopxml.BookProxy"></bean>

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

<!--配置 aop 增强-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="p" expression="execution(*com.study.spring5.aopxml.Book.buy(..))"/>
    <!--配置切面-->
    <aop:aspect ref="bookProxy">
        <!--增强作用在具体的方法上-->
        <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值