Spring的IOC和AOP课堂笔记

最新推荐文章于 2023-02-26 16:54:26 发布
最新推荐文章于 2023-02-26 16:54:26 发布
阅读量415 收藏
点赞数
分类专栏： SSM学习日记 文章标签： spring ioc aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ThisAaron/article/details/109199505
版权

1.Spring

1.1、简介

​ 轻量级框架，Java EE的春天，当前主流框架！

1.2、优点

  • Spring是一个开源的免费的框架(容器)！

  • Spring是一个轻量级的、非入侵式的框架！

  • 控制反转(IOC)，面向切面编程(AOP)！

  • 支持事务的处理，对框架集合的支持！

    总结：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架

2.IOC理论推导

  • 之前程序是主动创建对象，控制权在程序员手上
  • 使用set注入后，程序不再具有主动性，而是变成了被动的接收对象！
  • 这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建了。
  • 系统的耦合性大大降低~，可以更加专注地在业务的实现上！这是IOC的原型

2.1 控制反转为程序开发带来的好处是什么？**

​ 以前Dao是自己new出来的，编程完全控制在自己手里，通过Spring，初始化过程控制在容器手里，自己不用new它了，反转到容器里了

​ 原来我们的程序，我们控制的是具体的实现，写程序直接写实现。

​ 现在我们控制的是它的接口，它的抽象。原来我们依赖的是它的实现，现在我们依赖的是它的抽象，

​ 从具体的实现反转到抽象的概念上，我们针对的是接口编程，但真正注入进来的是具体的实现

2.2 面向切面编程的核心思想是什么？（AOP）

​ AOP在java里是利用反射机制实现的

​ 在不需要改变源代码的逻辑前提下，给系统的方法增加一些逻辑进去,并且这个逻辑是在整个程序的生命周期之内都能够应用.

3.IOC创建对象的方式

  1. 使用无参构造创建对象，默认！

  2. 假设我们要用有参构建创建对象

    1. 下标赋值

      <!--    第一种下标赋值！-->
<bean id="user" class="com.chen.pojo.User">
<constructor-arg index="0" value="赛飞"/>
<constructor-arg index="1" value="男"/>
</bean>

    2. 通过类型创建

      <!--    通过类型创建-->
<bean id="user" class="com.chen.pojo.User">
	<constructor-arg type="java.lang.String" value="赛贵妃"/>
	<constructor-arg type="java.lang.String" value="男"/>
</bean>

    3. 通过参数名进行注入

      <!--    通过参数名进行注入-->
    <bean id="user" class="com.chen.pojo.User">
        <constructor-arg name="gender" value="男"/>
        <constructor-arg name="name" value="赛飞"/>
    </bean>

    总结：在配置文件加载的时候，容器中管理的对象就已经被初始化了

4.Spring配置

4.1、别名

​ 如果添加了别名，我们也可以用别名获取到这个对象

    <alias name="user" alias="sdas"/>

4.2、Bean的配置

<!--    bean的配置
            id: bean 的唯一标识,也就是相当于我们学的对象名
            class: bean对象所对应的全限定类名,包名+类型
            name: 也是起别名,而且name可以同时起很多个，可用不同的分割(空格，逗号，分号)
        -->
    <bean id="user" class="com.chen.pojo.User" name="user2 user3,user4;user5">

4.3、import

​ 一般用于团推开发使用，它可以将多个配置文件，，导入合并成一个

​ 假设现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以用import将所有人的bean.xml合并成一个总的。

  • 张三
  • 李四
  • 王五

5.依赖注入

5.1、构造器注入

​ 前面试过了

5.2、Set方式注入【重点】

  • 依赖注入：Set注入

    • 依赖：bean对象的创建依赖于容器
    • 注入：bean对象中的所有属性,由容器来注入！

    【环境搭建】

    1. 复杂类型

    2. 真实测试对象

      <bean id="student" class="com.bdqn.pojo.Student">
    <!--        第一种，普通注入 value-->
    <property name="name" value="陈赛飞"/>
    <!--        第二种，Bean注入 ref-->
    <property name="address" ref="address"/>
    <!--        第三种，数组注入-->
    <property name="books">
        <array>
            <value>红楼梦</value>
            <value>西游记</value>
            <value>水浒传</value>
            <value>三国演义</value>
        </array>
    </property>
    <!--        第四种，List注入-->
    <property name="hobbys">
        <list>
            <value>听歌</value>
            <value>敲代码</value>
            <value>打篮球</value>
        </list>
    </property>
    <!--        第五种，Map注入-->
    <property name="card">
        <map>
            <entry key="身份证号" value="123456789012345678"/>
            <entry key="银行卡" value="12344332442"/>
            <entry key="手机号" value="123456778865"/>
        </map>
    </property>
    <!--        第六种，Set-->
    <property name="games">
        <set>
            <value>LOL</value>
            <value>COC</value>
            <value>BOB</value>
        </set>
    </property>
    <!--        第七种，空指针注入-->
    <property name="wife">
        <null/>
    </property>
    <!--        第八种，特殊类型-->
    <property name="info">
        <props>
            <prop key="学号">2019201293</prop>
            <prop key="QQ号">324234235</prop>
            <prop key="性别">男</prop>
        </props>
    </property>
</bean>

5.3、拓展方式注入

​ 我们可以使用，p命名空间和c命名空间进行注入

​ 官方解释:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-61LxMAeF-1603258955864)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201016165300104.png)]

​ 测试：

@Test
public void Student(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = (Student) context.getBean("student");
System.out.println(student);
}

​ 注意点：p命名和c命名空间不能直接使用，需要导入xml约束!

  1. p命名空间的作用：给属性赋值！
  2. c命名空间的作用：给有参构造函数的参数赋值！
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

6.Bean作用域(scope)

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cQ3tIsKb-1603258955870)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201016191459622.png)]

1.单例模式（默认机制）

​ singleton

<bean id="user" class="com.chen.pojo.User" name="user2" scope="singleton">

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jYPs6OWU-1603258955873)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201016191833227.png)]

2.原型模式

​ prototype 原型,每次从容器中get的时候，都会产生一个新对象

<bean id="user" class="com.chen.pojo.User" name="user2" scope="prototype">

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2s0bS17x-1603258955875)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201016192132673.png)]

3.其余的

​ request、session、application只能在web开发中使用到

7.Bean的自动装配

  • 自动装配Spring满足bean依赖一种方式！
  • Spring会在上下文中自动寻找，并自动改bean装配属性！

在Spring中有三种装配的方式

  1. 在xml中显示的配置
  2. 在java中显示配置
  3. 隐式的自动装配bean
    1. byName自动装配：根据自己对象的set方法的后面对应的name进行装配
    2. byType自动装配：根据自己对象属性类型相同的bean进行装配

使用注解实现自动装配

​ jdk1.5支持的注解，Spring2.5就支持注解了

​ 使用注解须知：

  1. 导入约束 context约束

  2. 配置注解配置 context:annotation-config/

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

    <context:annotation-config/>

</beans>
@Autowired

​ Spring支持的注解，优先查byType,其次查byName

​ 直接在属性上使用即可，也可以在set方式上使用！

​ 使用Autowired可以不编写set方法，因为它是用映射注入的

​ 属性（required = false） 对象不可以为空 true：可以为空

​ @Qualifier(value = ‘xx’)

​ 指定自动装配的值，前提是类型相同的前提下

@Resource

​ java原生注解,优先查byName,其次查byType

​ 属性name:指定配置的name

小结

​ @Resource和@Autowired的区别：

  • 相同点

    1. 都可以放在属性字段上

  • 不同点

    1. @Resource先通过byName找，找不到名字再用byType类型
    2. @Autowired先通过byType找，找不到类型再用byName找名字

8.Bean的生命周期

  • 生命周期：从创建到销毁的全过程！

Bean的执行顺序：

  1. 通过配置文件，执行bean 先执行构造方法！
  2. 赋值时执行set方法
  3. 初始化前，执行后置处理器中的初始化前的方法Before
  4. 执行初始化方法
  5. 初始化后，执行后置处理器中的初始化后的方法after
  6. 从ioc中获取对象
  7. 销毁对象执行destroy方法

​ 设置后置处理器后，beans中的所有的bean在有初始化的方法时，都会执行后置处理器中的前后方法

​

​ 普通类实现BeanPostProcessor接口实现方法！

9.使用注解开发

  • 在Spring4之后，要使用注解开发，必须保证AOP包导入了
  • 在使用注解需要导入，context约束，增加注解的支持

  1. bean

    • @Component 组件，放在类上，说明这个类被Spring容器管理了，相等于bean了

  2. 属性如何注入

    • @Value(“xxx”) 注解注入，放在字段上，通过映射的方式去注入，不再用set方法了

  3. 衍生的注解

    • @Component 有几个衍生注解，我们在web开发中，会按照mvc三层分层！
      • dao【@Repository】
      • service【@Service】
      • controller【@Controller】
        • 这四个注解功能都是一样的，都是代表将某个类注册到Spring中装配Bean

  4. 自动装配

    1. @Autowired 自动装配通过类型 名字，自动装配，名字如果不能唯一，则
      • @Qualifier(value=‘xx’)
    2. @Nullable 字段标记了这个注解，说明这个字段可以为空
    3. @Resource 自动通过名字，类型

  5. 作用域

    1. @Scope(“singleton”) 单例
    2. @Scope(“prototype”) 原型

  6. 小结

    • xml与注解

      • xml：更加万能，适用于任何场合！维护简单方便
      • 注解：不是自己的类引用不了,维护相对复杂！

      最佳实践：

      • ​ xml用来管理bean
      • 注解只负责完成属性的注入
      • 我们在使用的过程中，只需要注意：要想让注解生效，就要开启注解支持和扫描包

10.使用java的方式配置Spring

​ 我们现在要完全不使用spring的xml配置了，全权交给java来做！

javaConfig是Spring的一个子项目，在Spring4之后，它成为了核心功能

  1. 创建一个类作为配置类

    1. @Configuration 类似于Beans 可以让这个类成为配置类
    2. @ComponentScan 扫描类
    3. @Bean 注册，相当于 bean标签
      • 其中 方法名 == bean的id属性
      • 其次 返回值 == bean的class
    • /**
 * @Configuration 让这个类成为配置类  类似与Beans
 *      它也会注册到Spring 容器中，因为它本身也是一个@Component
 * @ComponentScan 扫描类，
 * @Bean 注册到bean，相当于我们之前写的一个bean标签
 *      方法名字 == bean标签的id属性
 *      返回值 == bean标签中的class
 */
@Configuration![在这里插入图片描述](https://img-blog.csdnimg.cn/20201021134704788.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RoaXNBYXJvbg==,size_16,color_FFFFFF,t_70#pic_center)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

 @ComponentScan("com.bdqn.pojo")
 @Import(ChenConfig2.class)
 public class ChenConfig {
     // 注册到bean，相当于我们之前写的一个bean标签
     @Bean
     public User getUser(){
         return new User();
     }
 } 
 ```

  1. 创建要实例的类

    • Value(“xx”) 给属性赋值

    • // 让这个类注册到容器里
@Component
public class User {
    public String getName() {
        return name;
    }
    @Value("Aaron and Amder")
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }

    private String name;
}

11.代理模式

​ 为什么要学习代理模式？因为这就是SpringAOP的底层 面试必问【SpringAOP 和 SpringMVC】

  • 代理模式的分类：
    • 静态代理
    • 动态代理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kik0D4pD-1603258955877)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201019184223032.png)]

11.1、静态代理

  • 角色分析：

    • 抽象角色：一般会使用接口或者抽象类来解决
    • 真实角色：被代理的而角色
    • 代理角色：代理真实角色，后我们一般会做附属操作
    • 客户：访问代理对象的人

  • 代码步骤：

    1. 接口

      public interface Rent {
    void rent();
}

    2. 真实对象

      public class Host implements Rent{
    public void rent() {
        System.out.println("房东要出租房屋");
    }
}

    3. 代理对象

      public class Proxy {
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }
    public void show(){
        host.rent();
        System.out.println("中介带客人去看房子");
        System.out.println("收中介费");
        System.out.println("签合同");
        System.out.println("拎包");
    }
}

    4. 客户端访问代理对象

      public class Client {
    @Test
    public void shos(){
        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.show();
    }
}

  • 代理模式的好处：

    • 可以让真实角色的操作更加纯粹！不用去关注公共业务
    • 公共业务交给代理角色！实现了业务的分工！
    • 公共业务发生扩展的时候，方柏集中管理！

  • 缺点

    • 一个真实角色就会产生一个代理对象，代码就会翻倍 开发效率会变低

11.2、加深理解

​ 代码步骤

  1. 接口

    public interface UserService {
    void add();
    void del();
    void upd();
    void sel();
}

  2. 真实对象

    public class UserServiceimpl implements UserService{
    public void add() {
        System.out.println("增加一个用户");
    }

    public void del() {
        System.out.println("删除一个用户");
    }

    public void upd() {
        System.out.println("修改一个用户");
    }

    public void sel() {
        System.out.println("查询一个用户");
    }
}

  3. 代理对象

    public class UserServiceProxy implements UserService {
    private UserServiceimpl userServiceimpl;

    public void setUserServiceimpl(UserServiceimpl userServiceimpl) {
        this.userServiceimpl = userServiceimpl;
    }

    public UserServiceProxy() {
    }

    public UserServiceProxy(UserServiceimpl userServiceimpl) {
        this.userServiceimpl = userServiceimpl;
    }

    public void add() {
        log4j("add");
        userServiceimpl.add();
    }

    public void del() {
        log4j("del");
        userServiceimpl.del();
    }

    public void upd() {
        log4j("upd");
        userServiceimpl.upd();
    }

    public void sel() {
        log4j("sel");
        userServiceimpl.sel();
    }
    public void log4j(String msg){
        System.out.println("使用了"+msg+"方法");
    }
}

  4. 客户测试类

    public class Client {
    @Test
    public void cli(){
        UserServiceimpl serviceimpl = new UserServiceimpl();
        UserServiceProxy proxy = new UserServiceProxy(serviceimpl);
        proxy.add();
    }
}

关于AOP实现图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DNWLzcOm-1603258955879)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201019194705749.png)]

11.3 动态代理

  • 动态代理和静态代理角色一样，
  • 动态代理的类是动态生成的，
  • 动态代理分为两大类
    • 基于接口的动态代理—JDK 动态代理
    • 基于类的动态代理—cglib
    • java字节码：javasist

需要了解两个类： Proxy 代理 ,invocationHandier 调用处理程序

  • 动态代理的好处
    1. 可以使真正角色的操作更加纯粹！不用去关注一些公共的业务
    2. 公共也就是交给代理角色！实现了业务的分工！
    3. 公共业务发生扩展的时候，方便集中管理！
    4. 一个动态代理类代理的是一个接口，一般就是对应的是一类业务
    5. 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！

12.AOP

11.1 什么是AOP

​ AOP意为：面向切面编程，通过预编译方式和运行期动态代理实现从程序功能的统一维护的一种技术，AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合降低，提高程序的可重用性，同时提高开发的效率

​ 在不通过修改源代码的方式，给他添加新功能！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LAeHZWre-1603258955880)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201021084040174.png)]

11.2 AOP在Spring中的作用

​ 提供声明式事务：允许用户自定义切面

  • 横向关注点：跨越应用程序多个模块的方法或功能，即使与我们业务逻辑无关的，但我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…

  • 切面：切面 是通知和切入的结合，切入点：在哪干，通知：干什么

  • 通知：切面必须要完成的工作。 它是类中的一个方法

    1. 前置通知(@Before)：方法前执行(一定执行)
    2. 后置通知(@AfterReturning): 方法后执行，目标方法没有异常 执行；有异常，不执行
    3. 异常通知(@AfterThrowing):方法发生异常时执行
    4. 最终通知(@After):相当于finally，，不论是否发生异常都执行
    5. 环绕通知(@Around): 前置，后置，异常，最终，四大增强方法的结合

  • 目标：被通知对象

  • 代理：向目标对象应用通知之后创建的对象

  • 切入点：实际被增强的方法 要加强的位置

  • 连接点：允许使用通知的地方 方法前后都是连接点

  • 织入：把切面应用到目标对象来创建新的代理对象的过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-stnWCDUF-1603258955883)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201020185637398.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oVoihvDN-1603258955884)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201020185734796.png)]

12.3 使用Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包！

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>
方式一： 使用Spring的API接口

  1. 创建接口和真实对象

    public interface UserService {
    void add();
}

public class UserServiceimpl implements UserService{
    public void add() {
        System.out.println("增加了一个用户");
    }
}

  2. 创建要增强的日志

    public class AfterLog4j implements AfterReturningAdvice {
    // o 返回值
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为:"+o);
    }
}

public class log4j implements MethodBeforeAdvice {
    // method: 要执行的目标对象的方法
    // objects: 参数
    // o: 目标对象
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

  3. 配置文件

    <!--    注册bean-->
    <bean id="userService" class="bdqn.chen.service.UserServiceimpl"/>
    <bean id="log4j" class="bdqn.chen.log.log4j"/>
    <bean id="afterLog4j" class="bdqn.chen.log.AfterLog4j"/>

<!--    配置aop:需要导入aop的约束-->
    <aop:config>
<!--    切入点-->
        <aop:pointcut id="pointcut1" expression="execution(* bdqn.chen.service.UserServiceimpl.*(..))"/>

<!--    执行环绕-->
        <aop:advisor advice-ref="log4j" pointcut-ref="pointcut1"/>
        <aop:advisor advice-ref="afterLog4j" pointcut-ref="pointcut1"/>
    </aop:config>
方式二：自定义来实现AOP

  1. 编写增强方法中的增强类

    public class Buftter {
    /**
     * 前置增强的方法
     */
    public void buffer(JoinPoint joinPoint){
        System.out.println("前置增强");
        System.out.println(joinPoint.getSignature().getName());
    }
    /**
     * 无异常的方法
     */
    public void afterReturning(){
        System.out.println("无异常的方法");
    }
    /**
     * 异常的方法
     */
    public void afterthrowing(){
        System.out.println("异常的方法");
    }
    /**
     * 最终通知
     */
    public void after(){
        System.out.println("最终通知");
    }
    /**
     * 环绕通知 ProceedingJoinPoint point
     */
    public void around(ProceedingJoinPoint point){
        try {
            System.out.println("环绕前置增强...");
            Object proceed = point.proceed();
            System.out.println("环绕后置增强...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        } finally {
            System.out.println("最终通知");
        }
    }
}

  2. 配置切入点，切面，通知

    <!--方式二-->
    <bean id="userService" class="bdqn.chen.service.UserServiceimpl"/>
    <bean id="buftter" class="bdqn.chen.log.Buftter"/>

    <aop:config>
        <!--    切入点-->
        <aop:pointcut id="poin" expression="execution(* bdqn.chen.service.UserServiceimpl.*(..))"/>

<!--        执行环绕-->
        <aop:aspect ref="buftter">
            <aop:before method="buffer" pointcut-ref="poin"/>
            <aop:after-returning method="afterReturning" pointcut-ref="poin"/>
            <aop:after-throwing method="afterthrowing" pointcut-ref="poin"/>
            <aop:after method="after" pointcut-ref="poin"/>
            <aop:around method="around" pointcut-ref="poin"/>
        </aop:aspect>
    </aop:config>
方式三：注解实现AOP

  1. ​ 创建增强类

    • @Aspect 标注这个类是一个切面
    • @Before(“execution(* bdqn.chen.service.UserServiceimpl.*(…))”) 前置增强
    • @AfterReturning(“execution(* bdqn.chen.service.UserServiceimpl.*(…))”) 无异常增强
    • @AfterThrowing(“execution(* bdqn.chen.service.UserServiceimpl.*(…))”) 出现异常时增强
    • @After(“execution(* bdqn.chen.service.UserServiceimpl.*(…))”) 执行方法后增强
    • @Around(“execution(* bdqn.chen.service.UserServiceimpl.*(…))”) 环绕增强
    • 同时存在时执行的顺序
      1. @Around（环绕前）
      2. @Before（执行方法前）
      3. pjp.proceed() （执行方法）
      4. @Around（环绕后）
      5. @After（执行方法后）
      6. @AfterReturning/@AfterThrowing（执行有异常增强方法/执行无异常增强方法）
    @Aspect // 标注这个类是一个切面
public class AnnotationPoinCut {
    @Before("execution(* bdqn.chen.service.UserServiceimpl.*(..))")       // 切入点
    public void before(JoinPoint joinPoint){
        System.out.println("执行"+joinPoint.getSignature().getName()+"方法前");
    }

    @AfterReturning("execution(* bdqn.chen.service.UserServiceimpl.*(..))")
    public void afterReturning(){
        System.out.println("无异常执行");
    }

    @AfterThrowing("execution(* bdqn.chen.service.UserServiceimpl.*(..))")
    public void afterThrowing(){
        System.out.println("出异常执行");
    }

    @After("execution(* bdqn.chen.service.UserServiceimpl.*(..))")
    public void after(){
        System.out.println("最终执行方法");
    }

    @Around("execution(* bdqn.chen.service.UserServiceimpl.*(..))")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前");
        Object proceed = pjp.proceed();
        System.out.println("环绕后");
        System.out.println(pjp.getSignature().getName());
        System.out.println(pjp.getSignature().getDeclaringType());
        System.out.println(pjp.getSignature().getDeclaringTypeName());
        System.out.println(pjp.getSignature());
    }
}

  2. 配置中注册增强类

    <!--    方式三-->
    <bean id="annotationPoinCut" class="bdqn.chen.diy.AnnotationPoinCut"/>
<!--    开启注解支持！JDK(默认 proxy-target-class="false")  cglib(proxy-target-class="false")-->
    <aop:aspectj-autoproxy proxy-target-class="true"/>

Joinpoint对象的使用

/**
* JoinPoint 对象做参数即可使用JoinPoint对象
*/
public void buffer(JoinPoint joinPoint){
    System.out.println("前置增强");
    System.out.println(joinPoint.getSignature().getName());
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

ThisAaron
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
深入理解Spring两大特性：IoC和AOP
null
02-14 9万+
众所周知，Spring拥有两大特性：IoC和AOP。。Spring核心容器的主要组件是Bean工厂（BeanFactory），Bean工厂使用控制反转（IoC）模式来降低程序代码之间的耦合度，并提供了面向切面编程（AOP）的实现。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器框架。下面，我们简要说明下这两大特性。
Spring中的IOC和AOP是什么意思？
weixin_45704311的博客
04-20 1万+
(1) Spring是什么？ IOC(控制反转)和AOP(面向方面编程)作为Spring框架的两个核心，很好地实现了解耦合。所以，简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。 spring的基本框架主要包含六大模块：DAO、ORM、AOP、JEE、WEB、CORE Spring DAO：Spring提供了对JDBC的操作支持：JdbcTemplate模板工具类 。 Spring ORM：Spring可以与ORM框架整合。例如Spring整...
Spring的IOC和AOP
凉城未暖夜微凉的博客
02-26 593
​ Spring是一个开原框架，是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。Spring的核心是控制反转（IoC）和面向切面（AOPSpring 是为了解决企业级应用开发的复杂性而创建的。在 Spring 之前，有一个重量级的工具叫做 EJB，使用 Spring 可以让 Java Bean 之间进行有效的解耦，而这个操作之前只有 EJB 才能完成，EJB 过于臃肿，使用很少。Spring 不仅仅局限于服务端的开发，在测试性和松耦合方面都有很好的表现。
SpringIOC与SpringAOP（例子+知识点结合）
weixin_53142260的博客
01-24 1475
SpringIOC与SpringAOPSpringIOC与SpringAOP是什么？IoC控制反转SpringIOC具体使用方法bean标签的属性基于注解实现SpringIOC——重要AOP面向切面AOP的实现机制-动态代理静态代理动态代理基于JDK的动态代理基于CGLIB的动态代理SpringAOPSpringAOP相关概念AspectJ 对 AOP 的实现AspectJ的通知类型AspectJ的切入点表达式注解方式实现AOP SpringIOC与SpringAOP是什么？ IoC（控制反转）与AOP（面
Spring的AOP和IOC是什么？
qq_43582619的博客
01-24 1万+
1.AOP（Aspect Oriented Programming） 也叫做------面向切面编程。是一种通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）。AOP面向方面编程基于IoC，是对OOP的有益补充。 AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了 多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些..
Spring5-尚硅谷框架课堂笔记.rar
08-10
《Spring5 尚硅谷框架课堂笔记》是一份深入解析 Spring 框架的珍贵资料，主要针对 Spring 5 版本进行了详尽的讲解。Spring 是一个开源的 Java 应用程序框架，它以 IoC（Inversion of Control，控制反转）和 AOP...
spring课堂笔记.docx
最新发布
09-05
Spring 框架的核心技术主要包括控制反转（IoC）和面向切面编程（AOP），这些概念和技术都是为了提高代码的可维护性和可扩展性。 控制反转（IoC）是Spring框架的基础，其核心思想是将对象的创建和管理权交给了框架...
Spring5框架课堂笔记.7z
12-03
1. **Spring概述**：Spring是一个开源的Java平台，它简化了Java应用程序的开发，通过提供IOC（Inversion of Control，控制反转）和AOP（Aspect-Oriented Programming，面向切面编程）等核心特性，实现了组件的解耦和...
Spring5框架课堂笔记10307327.rar
08-07
这份"Spring5框架课堂笔记10307327.rar"的压缩包文件包含了关于Spring5框架的深入学习资料，特别是以PDF形式的讲义，将帮助我们全面理解这个框架的核心概念和实际应用。 首先，Spring5框架的基础部分包括IoC容器和...
软件工程课堂笔记+期末试题
07-05
软件工程课堂笔记+期末试题.... 内容概要:通过带着读者手写简化版 Spring框架，了解 Spring核心原理。在手写Spring源码的过程中会摘取整体框架中的核心逻辑，简化代码实现过程,保留核心功能，例如:IOC、AOP、Bean...
Spring的AOP和IOC
wangziman的博客
04-14 1901
首先了解AOP呐就要了解spring的优点以及DI这个概念，来引入我们的AOP. spring 的优点？ 1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦 2.可以使用容易提供的众多服务，如事务管理，消息服务等 3.容器提供单例模式支持 4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能 5.容器提供了众多的辅助类，能加快应用的开发 6.spring对于主流的应用框架提供...
【Java面试】谈谈自己对于 Spring IoC 和 AOP 的理解
挨踢小子的博客
09-10 1万+
IOC解析 IoC（Inverse of Control:控制反转）是一种设计思想，就是 将原本在程序中手动创建对象的控制权，交由Spring框架来管理。 IoC 在其他语言中也有应用，并非 Spirng 特有。 IoC 容器是 Spring 用来实现 IoC 的载体， IoC 容器实际上就是个Map（key，value）,Map 中存放的是各种对象。 将对象之间的相互依赖关系交给 IoC 容器来...
spring IOC与AOP
qq_40058686的博客
01-30 369
spring是什么？ spring是一个轻量级的ioc和aop容器框架 常见的配置方式：基于XML配置，基于注解的配置，基于java的配置 spring的优点？ 1）spring属于低侵入式设计，对代码的污染极低 2）spring的DI机制将对象之间的依赖关系交由框架处理，降低组件的耦合性 3）spring提供了AOP技术，支持将一些通用任务集中管理，从而得到更好的复用 4）s...
Spring的IOC与Aop
醉逸鎏年的博客
10-25 240
Spring的IOC与Aop
Spring的IOC和AOP原理
热门推荐
子冉冰清的博客
09-26 2万+
Spring的IOC和AOP原理 本文讲的是面试之Spring框架IOC和AOP的实现原理， IoC（Inversion of Control） (1). IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移是所。 IoC（Inversion of Control） (1). IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。
aop面向切面编程原理,这个比喻我服辣,6翻了
凤歌
01-08 8331
aop面向切面编程原理讲解
什么是AOP
lyk621x的专栏
06-17 581
  What is AOP？AOP即Aspect-OrientedProgramming的缩写，中文意思是面向切面编程，也有译作面向方面编程的，因为Aspect有“方面、见地”的意思。AOP实际上是一种编程思想，由Gregor Kiczales在PaloAlto研究中心领导的一个研究小组于1997年提出[1]。在传统的面向对象（Object-Oriented Program
什么是Spring IoC 和 AOP？
weixin_45958328的博客
07-30 950
IoC 是 Spring 全家桶各个功能模块的基础，是创建对象的容器。AOP 也是以 IoC 为基础，AOP 是面向切面编程，抽象化的面向对象
Spring学习笔记（IOC,DI和AOP）
MarkZP
03-05 269
IOC： Inversion of Control，控制反转， 控制权从应用程序转移到框架（如IOC容器），是框架共有的特性。 对于IOC的理解，可以把IOC看作是一个生产和管理bean对象的容器。原本程序中我们要手动自己创建（new）的对象统统交给Spring的IOC容器帮我们创建。同时这就意味着，要产生的单例的bean，这个对象的生命周期也是有IOC容器管理。 Spring中IOC的三种实...
spring ioc和aop
03-29
Spring IOC（Inversion of Control）和AOP（Aspect-Oriented Programming）是Spring框架的核心特性。 1. Spring IOC（控制反转）是一种设计模式，它将对象的创建和依赖关系的管理从代码中剥离出来，交给容器来管理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值