spring框架 IOC（注解方式开发）AOP（xml方式开发）

最新推荐文章于 2022-08-14 11:58:31 发布
最新推荐文章于 2022-08-14 11:58:31 发布
阅读量238 收藏
点赞数 1
分类专栏： 框架篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44142032/article/details/90704178
版权

目录

spring IOC注解方式开发

spring框架4.X版本以上开发，IOC注解方式开发要比XML方式开发多导入一个AOP的jar包，主要是一些类的属性封装到了AOP的jar包的接口中。

注解开发实例

  1. 导入相关jar包
    在这里插入图片描述
  2. 创建接口UserDao.java 和 实现类UserDaoImpl.java,并在类上添加注解
接口
public interface UserDao {
    public void save();
}

================================================
实现类
import com.web.dao.UserDao;
import org.omg.IOP.ComponentIdHelper;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import org.springframework.web.bind.annotation.InitBinder;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

//@Component(value = "userDao")
//相当于xml方式：<bean id="userDao" class="com.web.dao.impl.UserDaoImpl" />
@Repository(value = "userDao")
@Scope(value = "prototype")
public class UserDaoImpl implements UserDao {

    @PostConstruct
    public void init(){
        System.out.println("对象初始化调用该方法");
    }
    //当给属性赋值的时候，可以有set方法，有的时候，把注解放在set方法上，或者放在属性上都可以。
    //也可以没有set方法，没有的时候，直接把注解放在属性上就可以
    
    //    @Value(value = "王二小")
    private String name;
//    @Autowired
//    @Qualifier(value = "car")
//    @Resource(name = "car")
    private Car car;

    @Value(value = "哈哈哈")
    public void setName(String name) {
        this.name = name;
    }

//    @Autowired
//    @Qualifier(value = "car")
    @Resource(name = "car")
    public void setCar(Car car) {
        this.car= car;
    }

    @Override
    public void save() {
        System.out.println("执行了UserDao中的方法");
    }

    @PreDestroy
    public void distory(){
        System.out.println("对象销毁调用该方法");
    }
}
  1. 配置applicationContext.xml文件，放在src目录下

注意：要引入context约束
在spring的解压路径下spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html 的html中有scamer约束，复制下来就可以。

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- bean definitions here -->
	
	<!--要引入context约束-->
    <!--使用注解的方式，先进行扫描该包下的加注解@Component的类-->
    <!--注意：是扫描的扫描类上的注解-->
    <context:component-scan base-package="com"  ></context:component-scan>

    <!--不扫描类的情况下，使用注解进行属性注入
		@Resource  @Autowited @Value @Qualifier 
-->
    <context:annotation-config></context:annotation-config>

</beans>
  1. 创建测试类SpringDemo.java
import com.service.UserService;
import com.web.dao.UserDao;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDemo {
    @Test
    /**
     * 使用注解方式IOC
     */
    public void demo1(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
//        userDao.save();
        UserDao userDao2 = (UserDao) applicationContext.getBean("userDao");
//        userDao.save();
        System.out.println(userDao);
        System.out.println(userDao2);
        ((ClassPathXmlApplicationContext) applicationContext).close();
    }

    @Test
    /**
     * 使用注解方式IOC
     * 属性的注入
     */
    public void demo2(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.save();
    }
}

spring 的IOC注解方式的详解

类的注解，Bean的管理

@Component注解：组件
这个注解有三个衍生的注解，功能和@Component差不多

  1. @Controller：web层注解
  2. @Service：service层注解
  3. @Repository：dao层注解

作用：修饰一个类，将这个类交给spring框架管理
为什么分开呢？因为便于框架的分层结构的清晰，每一层的注解会有一些相对应该层的属性。

@Component注解是可以修饰任何一层的类的，注解上该类之后，
@Component(value="userDao")------ value可以省略 @Component("userDao")
相当于xml配置文件中
<bean id="userDao" class="xxx.xxx.xx" />

属性注入的注解

  • 基本类型属性的注入

@Value(value="xxx") ,------其中value可以省略 @Value("xxx")
注解可以写在属性上，也可以写在set方法上

  1. 当没有set方法时候，也可以，将注解写在属性上
  2. 当有set方法的时候，注解可以写在属性上，也可以写在set方法上
  • 引用类型属性的注入
  • @ Autowired
    该注解默认设置对象属性的值，是按照类型完成属性的注入。
    我们习惯按照名称完成属性的注入：必须让
  • @Autowired 和 @Qualifiter
    注解一起使用，就可以按照名称注入值
  • @Resource(name="user") ,完成属性的注入，是按照名称来注入的。这个是spring实现了其他的接口规范实现的。
  • 注解可以写在属性上，也可以写在set方法上
    • 当没有set方法时候，也可以，将注解写在属性上
    • 当有set方法的时候，注解可以写在属性上，也可以写在set方法上

<bean id="car" class="com.domain.Car"></bean>
<bean id="customer" class="com.domain.Customer">
    <property name="name" value="王五"></property>
    <property name="car" ref="car"></property>
</bean>
id=car  ，ref=car，值必须相等，如果id=caee，那么ref=caee才可以，
这就是引用类型按名称注入。
如果使用注解的方式
@Autowired
@Qualifier(value = "car")，同时使用才可以，而Car对象的@Component(value="car")，
value必须一样才可以。
如果只使用@Autowired注解，名字不同也没事，因为是按照类型完成属性的注入。

Bean其他的注解

  • Bean的生命周期
  1. @PostConstruct：初始化方法，在一个方法上写上该注解，类初始化的时候就会调用该方法
  2. @PreDestory：销毁方法，在一个方法上写上该注解，类销毁的时候就会调用该方法
  • Bean的作用范围

@Scope(value="xxx")
值由以下几个：
singleton ：默认的，单例模式创建对象，Spring会采用单例模式创建这个对象。
prototype ：多例模式。（Struts2和Spring整合一定会用到）
request ：应用在web项目中，Spring创建这个类以后，将这个类存入到request范围中。
session ：应用在web项目中，Spring创建这个类以后，将这个类存入到session范围中。
globalsession ：应用在web项目中，必须在porlet环境下使用。但是如果没有这种环境，相对于session。

IOC的xml方式和注解方式开发的比较

适用场景

  1. xml方式：适用于任何场景
    优点：便于后期的维护，结构清晰
  2. 注解方式：有些地方用不了，这个类不是自己提供的，没办法加注解
    优点：开发方便

xml和注解整合开发

XML用来管理Bean，注解完成属性的注入

当这种情况下，Bean的管理是使用xml方式实现的，所以不用扫描类的情况下使用注解完成属性注入，必须在applicationContext.xml文件中配置

  <!--不扫描类的情况下，使用注解进行属性注入-->
    <context:annotation-config></context:annotation-config>

spring的AOP(XML方式开发)

AOP的概述

面向切面编程：是一种开发思想，产生代理对象。而spring框架是运用这种思想最好的框架。增强某种方法的功能，spring框架不需要自己去写代码，根据一些配置文件就能自动生成。在不能继承，不能修改源码的情况下非常方便。
AOP是OPP的扩展和延伸，解决OPP（面向对象的开发）开发中遇到的问题。

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

spring的底层AOP实现原理（了解）

底层的实现主要是根据产生代理对象实现功能增强的一种切面式开发方式

  • 产生代理对象有两种方式。
  1. JDK动态代理。jdk提供的只能对实现接口的类产生代理对象。
  2. 第三方提供的 Cglib 动态代理。对没有实现接口的类产生代理对象， 生成子类的对象（类似于javassist第三方代理技术）。

JDK动态代理

public class MyProxy implements InvocationHandler {
    Customer customer;
    public MyProxy(Customer customer) {
        this.customer = customer;
    }
    public Customer createProxy(){
        Customer o = (Customer)Proxy.newProxyInstance(MyProxy.class.getClassLoader(), CustomerImpl.class.getInterfaces(),this);
        return o;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object o = null;
        if (method.getName().equals("save")){
            //增强功能
            System.out.println("权限校验");
            o = method.invoke(customer, args);
        }else {
            o = method.invoke(customer,args);
        }
        return o;
    }
}
====================================================================
public class springDemo2 {
    @Test
    //不加强运行
    public void demo1(){
        CustomerImpl customer = new CustomerImpl();
        customer.save();
    }
    @Test
    //加强功能后运行
    public void demo2(){
        MyProxy myProxy = new MyProxy(new CustomerImpl());
        Customer customer = myProxy.createProxy();
        customer.save();
    }
}

Cglib动态代理

public class CglibProxy implements MethodInterceptor {
    Customer customer;
    public CglibProxy(Customer customer){
        this.customer = customer;
    }

    public Customer createCglibProxy(){
        //创建Cglib的核心类对象
        Enhancer enhancer = new Enhancer();
        //设置目标类,也就是设置目标类，要代理哪个对象，（生成代理对象是其目标类的子类）
        enhancer.setSuperclass(customer.getClass());
        //设置回调(MethodInterceptor类似于InvocationHandle对象)
        enhancer.setCallback(this);
        //返回代理对象
        Customer o = (Customer)enhancer.create();
        return o;
    }


    @Override
    //类似于invoke()方法
    public Object intercept(Object proxy, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        if(method.getName().equals("find")){
            //增强
            System.out.println("权限校验");
            //执行原方法，使用方法的代理对象methodProxy，不是用method
            //第一个参数：生成的代理对象
            //第二个参数：原方法里面的参数，没有默认为null
            return methodProxy.invokeSuper(proxy, objects);
        }
        return methodProxy.invokeSuper(proxy,objects);
    }
}
========================================================================
public class springDemo2 {
    @Test
    //使用Cglib的方式产生动态代理对象
    public void demo3(){
        CglibProxy cglibProxy = new CglibProxy(new CustomerImpl());
        Customer customer = cglibProxy.createCglibProxy();
        customer.find();
    }
}

spring的AOP的开发

spring的AOP的简介

AOP是一种由AOP联盟组织提出的思想，而spring框架是将这种思想运用最好的框架

  • spring框架中实现AOP思想的开发方式
    • spring自己的AOP的实现方式（繁琐，以弃用）
    • spring引入的第三方的AspectJ框架（是AOP的框架），spring引入AspectJ作为自身的AOP的开发。（推荐使用）

spring的AOP开发中的相关术语

在这里插入图片描述

spring的AOP的入门

创建web项目，引入相关的jar包

在这里插入图片描述

引入spring的配置文件

<?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: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">

    <!--设置目标对象：要增强的对象-->
    <bean id="customer" class="com.dao.impl.CustomerImpl"></bean>

    <!--设置切面类：将切面类交给spring管理-->
    <bean id="myAspectXML" class="com.web.spring.MyAspectXML"></bean>

    <!--通过AOP配置，生成要增强类的代理对象-->
    <!--底层根据要增强的类是否实现了接口，如果实现了接口，用jdk提供的动态代理生成对象，
        如果没有实现接口，用cglib动态代理生成代理对象。-->
    <aop:config>
        <!--id：标签的唯一标识，自己随便写。-->
        <!--expression: 表达式，标识要增强的哪个类和哪个方法-->
        <!--配置那些类哪个方需要增强-->
        <aop:pointcut id="pointcut1" expression="execution(* com.dao.impl.CustomerImpl.find(..)) "/>
        <aop:pointcut id="pointcut2" expression="execution(* com.dao.impl.CustomerImpl.delete(..)) "/>
        <aop:pointcut id="pointcut3" expression="execution(* com.dao.impl.CustomerImpl.save(..)) "/>
        <aop:pointcut id="pointcut4" expression="execution(* com.dao.impl.CustomerImpl.update(..)) "/>
        <!--配置切面-->
        <aop:aspect ref="myAspectXML">
            <!--method：切面类的某一个方法名。 pointcut-ref：将这个切面类的方法应用在要增强的类的某个方法中-->
            <!--前置通知-->
            <aop:before method="before" pointcut-ref="pointcut1" ></aop:before>
            <!--后置通知，可以接收原方法中返回的值-->
            <aop:after-returning method="after" pointcut-ref="pointcut2" returning="aa"></aop:after-returning>
            <!--环绕通知，可以不运行原方法-->
            <aop:around method="around" pointcut-ref="pointcut3" ></aop:around>
            <!--异常通知，当原方法有异常的时候，输出异常信息-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="ex"></aop:after-throwing>
            <!--最终通知，不论是否发生异常，都会通知-->
            <aop:after method="afterAll" pointcut-ref="pointcut4"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

编写目标类并完成配置

=====接口===================
package com.dao;

public interface Customer {
    public void save();
    public void find();
    public void update();
    public String delete();
}
==============================================================
========实现类========
package com.dao.impl;

import com.dao.Customer;

public class CustomerImpl implements Customer {
    @Override
    public void save() {
        System.out.println("保存用户");
    }

    @Override
    public void find() {
        System.out.println("查找客户");
    }

    @Override
    public void update() {
        System.out.println("更新用户");
//        int a = 3/0;
    }

    @Override
    public String delete() {
        System.out.println("删除用户");
        return "哈哈哈";
    }
}

编写测试类

//这两行的作用：spring整合junit，加载spring工厂，ApplicationContext，并加载配置文件。
//优点：就不用每次都生成工厂，使用getBean()获得对象了。
//需要导入spring-test-4.2.4.RELEASE.jar包

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")

package com.web.spring;

import com.dao.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

//这两行的作用：spring整合junit，加载spring工厂，ApplicationContext，并加载配置文件。
//优点：就不用每次都生成工厂，使用getBean()获得对象了。
//需要导入spring-test-4.2.4.RELEASE.jar包
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class springDemo3 {
    @Resource(name = "customer")
    public Customer customer;

    @Test
    public void demo(){
        customer.find();
        customer.delete();
        customer.save();
        customer.update();
    }
}

编写切面类

package com.web.spring;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 增强方法的类，切面类
 */
public class MyAspectXML {

    public void before(){
        System.out.println("执行前增强了权限校验的功能");
    }

    public void after( Object aa){
        System.out.println("执行之后增强了记录日志的功能"+aa);
    }

    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前通知");
        proceedingJoinPoint.proceed(); //执行原方法，也可以选择不执行
        System.out.println("环绕后通知");
    }

    public void afterThrowing( Throwable ex) throws Throwable {
        System.out.println("异常抛出通知==="+ex.getMessage());
    }

    public void afterAll() {
        System.out.println("最终通知,无论是否有异常，都会通知===");
    }
}

通过AOP的配置（基于AspectJ的方式的XML方式）完成目标类代码的增强

 <!--设置目标对象：要增强的对象-->
    <bean id="customer" class="com.dao.impl.CustomerImpl"></bean>

    <!--设置切面类：将切面类交给spring管理-->
    <bean id="myAspectXML" class="com.web.spring.MyAspectXML"></bean>

    <!--通过AOP配置，生成要增强类的代理对象-->
    <!--底层根据要增强的类是否实现了接口，如果实现了接口，用jdk提供的动态代理生成对象，
        如果没有实现接口，用cglib动态代理生成代理对象。-->
    <aop:config>
        <!--id：标签的唯一标识，自己随便写。-->
        <!--expression: 表达式，标识要增强的哪个类和哪个方法-->
        <!--配置那些类哪个方需要增强-->
        <aop:pointcut id="pointcut1" expression="execution(* com.dao.impl.CustomerImpl.find(..)) "/>
        <aop:pointcut id="pointcut2" expression="execution(* com.dao.impl.CustomerImpl.delete(..)) "/>
        <aop:pointcut id="pointcut3" expression="execution(* com.dao.impl.CustomerImpl.save(..)) "/>
        <aop:pointcut id="pointcut4" expression="execution(* com.dao.impl.CustomerImpl.update(..)) "/>
        <!--配置切面-->
        <aop:aspect ref="myAspectXML">
            <!--method：切面类的某一个方法名。 pointcut-ref：将这个切面类的方法应用在要增强的类的某个方法中-->
            <!--前置通知-->
            <aop:before method="before" pointcut-ref="pointcut1" ></aop:before>
            <!--后置通知，可以接收原方法中返回的值-->
            <aop:after-returning method="after" pointcut-ref="pointcut2" returning="aa"></aop:after-returning>
            <!--环绕通知，可以不运行原方法-->
            <aop:around method="around" pointcut-ref="pointcut3" ></aop:around>
            <!--异常通知，当原方法有异常的时候，输出异常信息-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="ex"></aop:after-throwing>
            <!--最终通知，不论是否发生异常，都会通知-->
            <aop:after method="afterAll" pointcut-ref="pointcut4"></aop:after>
        </aop:aspect>
    </aop:config>

spring中的通知类型

前置通知

<aop:config>
        <!--id：标签的唯一标识，自己随便写。-->
        <!--expression: 表达式，标识要增强的哪个类和哪个方法-->
        <!--配置那些类哪个方需要增强-->
        <aop:pointcut id="pointcut1" expression="execution(* com.dao.impl.CustomerImpl.find(..)) "/>
        <!--配置切面-->
        <aop:aspect ref="myAspectXML">
            <!--method：切面类的某一个方法名。 pointcut-ref：将这个切面类的方法应用在要增强的类的某个方法中-->
            <!--前置通知-->
            <aop:before method="before" pointcut-ref="pointcut1" ></aop:before>
            </aop:after>
        </aop:aspect>
    </aop:config>

后置通知

后置通知，可以获得原方法返货的值
注意：在xml文件中的returning属性的值是自己定义的，在对应的切面类的方法中的参数名要与returning属性中的值一样才可以
public void after( Object aa){
System.out.println(“执行之后增强了记录日志的功能”+aa);
}

<aop:config>
        <!--id：标签的唯一标识，自己随便写。-->
        <!--expression: 表达式，标识要增强的哪个类和哪个方法-->
        <!--配置那些类哪个方需要增强-->    
        <aop:pointcut id="pointcut2" expression="execution(* com.dao.impl.CustomerImpl.delete(..)) "/>  
        <!--配置切面-->
        <aop:aspect ref="myAspectXML">  
            <!--后置通知，可以接收原方法中返回的值-->
            <aop:after-returning method="after" pointcut-ref="pointcut2" returning="aa"></aop:after-returning>   
        </aop:aspect>
</aop:config>

环绕通知

环绕通知，可以不用运行原方法，运行原方法如下：
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println(“环绕前通知”);
proceedingJoinPoint.proceed(); //执行原方法，也可以选择不执行
System.out.println(“环绕后通知”);
}

<aop:config>
        <!--id：标签的唯一标识，自己随便写。-->
        <!--expression: 表达式，标识要增强的哪个类和哪个方法-->
        <!--配置那些类哪个方需要增强-->     
        <aop:pointcut id="pointcut3" expression="execution(* com.dao.impl.CustomerImpl.save(..)) "/>
        <!--配置切面-->
        <aop:aspect ref="myAspectXML">
            <!--method：切面类的某一个方法名。 pointcut-ref：将这个切面类的方法应用在要增强的类的某个方法中--> 
            <!--环绕通知，可以不运行原方法-->
            <aop:around method="around" pointcut-ref="pointcut3" ></aop:around>
        </aop:aspect>
    </aop:config>

异常通知

异常通知：当原方法执行发生异常的时候运行增强的方法，并且可以输出异常
注意：异常的输出，throwing属性的值是自己定义的，而切面类中的增强方法中的参数名要和自定义的throwing的属性值一样

<aop:config>
        <!--id：标签的唯一标识，自己随便写。-->
        <!--expression: 表达式，标识要增强的哪个类和哪个方法-->
        <!--配置那些类哪个方需要增强-->
        <aop:pointcut id="pointcut4" expression="execution(* com.dao.impl.CustomerImpl.update(..)) "/>
        <!--配置切面-->
        <aop:aspect ref="myAspectXML">
            <!--method：切面类的某一个方法名。 pointcut-ref：将这个切面类的方法应用在要增强的类的某个方法中-->
            <!--异常通知，当原方法有异常的时候，输出异常信息-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="ex"></aop:after-throwing>
        </aop:aspect>
    </aop:config>

最终通知

<aop:config>
        <!--id：标签的唯一标识，自己随便写。-->
        <!--expression: 表达式，标识要增强的哪个类和哪个方法-->
        <!--配置那些类哪个方需要增强-->
        <aop:pointcut id="pointcut4" expression="execution(* com.dao.impl.CustomerImpl.update(..)) "/>
        <!--配置切面-->
        <aop:aspect ref="myAspectXML">
            <!--method：切面类的某一个方法名。 pointcut-ref：将这个切面类的方法应用在要增强的类的某个方法中-->
            <!--最终通知，不论是否发生异常，都会通知-->
            <aop:after method="afterAll" pointcut-ref="pointcut4"></aop:after>
        </aop:aspect>
</aop:config>

spring切入点的expression表达式的写法

基于execution()函数wang完成的。

  • 语法格式：execution(语法格式) *号代表任意字符
  • [权限修饰符] 方法返回值 包名.类名.方法名(参数)
    • public void com.dao.impl.CustomerImpl.update(…)
    • * com.*Dao.save(..)，com包下的以Dao结尾的类中的save()方法
    • * com.dao.CustomerImpl+.save(..),com.dao包下的CustomerImpl类以及其所有子类下的save()方法
    • * com.dao..*.*(..),com.dao包以及这个包下的所有子包的所有类的所有方法
侯侯侯先生
关注
专栏目录
“掌握Spring IoC和AOP：30道面试必备问题解析！“
weixin_44976692的博客
01-03 2万+
在面试过程中，Spring的IoC（控制反转）和AOP（面向切面编程）是被频繁问及的重要主题。掌握这两个核心概念和技术，对于成为一名优秀的Java开发者至关重要。本篇博客将为你提供一份包含20个关键问题的面试指南，助你在面试中游刃有余，展现出对Spring IoC和AOP的深刻理解。无论你是初学者还是有经验的开发者，这20个问题将覆盖IoC和AOP的核心知识点，帮你更好地准备面试。让我们一同深入探讨，揭秘Spring的IoC和AOP的奥秘，为你的面试之路加分不少！🚀💻。
Spring 基于基于XML配置方式实现AOP
04-19
NULL 博文链接：https://huangminwen.iteye.com/blog/1486876
Spring_02---Spring注解开发、AOP操作(配置xml方式、注解方式)
一万年行不行的博客
11-12 311
一、Spring注解开发 1）注解创建对象 创建对象有四个注解，四个注解功能暂时相同，都为创建对象 （1）@Component （2）@Controller （3）@Service （4）@Repository 步骤： 1）导包 2）创建类，创建方法。 3）在类上添加注解。 4）创建配置文件，引入约束 5）开启注解扫描 代码示例： //注解类创建对象 @Compon...
springAOP(基于注解开发)
miracle
02-09 242
五.springAOP(基于注解开发) 1.导包和springAOP XML开发一样 2.前置通知，后置通知示例： eg： applicationContext.xml &amp;lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&amp;gt; &amp;lt;beans xmlns=&quot;http://www.springframework.org/schema/be
Aop学习笔记-- 基于xml和Aspect 注解方式实现AOP
每天写程序
05-28 384
AOP 术语 通知： 就是增强的方法（如记录日志，事务等） 连接点：就是指Spring允许你增强的地方都可以称为连接点，Spring支持方法连接点，所以方法的前后都可以是连接点。 切入点： 就是在连击点的基础上，来定义切入点。不想把通知运用到所有的方法上，就可以定义切入点。 切面就是通知+切入点。 通知类型： 1> @Before: 前置通知，在方法执行前执行 2> @After:...
【Spring 】【AOP】XML开发
zyk的博客
11-27 110
一、使用AOP进行单元测试 1.引入jar包 2.引入xml提示（为XML AOP做准备，可有可无） http://www.springframework.org/schema/aop/spring-aop.xsd 在window-&gt;preference-&gt;输入xml,找到xml catalog--&gt;add,url填上面那个，选择filesystem，选对应的.xsd...
Spring IOC和Spring AOP_spring aop_springIOC
09-24
Spring框架是Java开发中最常用的轻量级框架之一，它的核心特性包括依赖注入（Dependency Injection，简称DI）和面向切面编程（Aspect-Oriented Programming，简称AOP）。这两个概念是Spring框架的基石，极大地简化了...
手写spring框架ioc+aop+mvc
11-01
Spring 框架是 Java 开发中的核心工具之一，它为开发者提供了强大的依赖注入（IOC）和面向切面编程（AOP）功能，同时也包含了 MVC 模式来支持 web 应用开发。在这个"手写 spring 框架 ioc+aop+mvc"的项目中，我们将...
关于IoC、DI、AOP、spring框架、spring boot框架的理解
qq_49490940的博客
08-14 419
IoC、DI、AOP、spring框架、spring boot框架的理解
仿 Spring 手写 IoC、AOP 框架.rar
10-23
在IT领域，Spring框架是Java开发中的一个基石，尤其在企业级应用开发中扮演着重要角色。Spring的主要功能包括依赖注入（IoC）和面向切面编程（AOP）。本教程将带你深入理解这两个概念，并通过手写一个简易的IoC和AOP...
@Component("userService").@Resource(name="userDao")
weixin_33923762的博客
05-28 346
@Component("userService") public class UserService { private UserDAO userDao; public void init() { System.out.println("init"); } public void add(Us...
Spring 基于Aspectj的注解开发AOP(二)-后置通知@AfterReturning
路西法Lucifer
03-21 1739
附：参考Spring 基于Aspectj的注解开发AOP(一)-前置通知 将目标方法改成有返回值的； public String update() { System.out.println("修改商品"); return "hello"; } 在切面类中，将后置通知的方法加上 @AfterReturning注解，并配置作用的范围，以及返回值ret...
spring注解（三）使用注解代替xml配置
u010513603的博客
12-06 4670
spring框架为我们提供了注解功能。   使用注解编程，主要是为了替代xml文件，使开发更加快速。但是，xml文件的使用就是解决修改程序修改源代码，现在又不去使用xml文件，那么不就违背了开闭原则了么，得确是。不过么，注解也有注解的好，使用注解就不用配置那么多的xml文件啦，最重要的是开发效率高。。   在没有使用注解时，spring框架的配置文件applicationContext
Spring的基本配置和Spring与Mybatis的整合
热门推荐
CodeChen
10-29 7万+
Spring:               Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪...
spring框架之AspectJ基于xml和基于注解
qq_43161124的博客
10-06 577
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 今天写...
spring使用注解方式完成IOC和AOP功能
guoyp2126的博客
04-24 1388
前言 控制反转依赖注入（IOC）及AOP是spring的核心功能，spring使用xml文件完成配置，基本上已经废弃，目前主流的是使用注解的方式完成这两项功能。以下通过示例，演示注解的方式，实现IOC和AOP。 创建maven工程 输入工程名称，完成工程创建。打开pom文件，加入spring依赖包 在main目录下加入resource文件夹，并将其设置为Resources Root 在resources文件夹下，创建spring配置文件，applicationContext.xml IOC依赖注入
Spring4 IOC注解开发和xml开发对比
23号员工的博客
06-05 434
1 创建web项目 2 引入jar包（Spring4的版本需要多引入一个aop的包） 3 编写applicationContext.xml配置文件 注解 ====================== a.引入的是beans的schema b.只需要配置扫描那些包下的类即可 <context:component-scan base-package="com.sprin...
Feign实现微服务进行接口之间的调用
weixin_44142032的博客
06-11 9119
目录什么是FeignFeign能干什么？Feign是面向接口+注解的形式去调用FeignFeign与Ribbon的关系（Feign集成了Ribbon）Feign的构建 什么是Feign 官网地址 Feign是一个声明式的Web服务客户端， 使得编写Web服务客户端变得非常容易, 只需要创建一个接口，然后在上面添加注解即可。 Feign能干什么？ Feign是面向接口+注解的形式去调用Feign github官网地址 Feign与Ribbon的关系（Feign集成了Ribbon） Feign集成了Rib
Spring框架深度解析：IOC与AOP自我实现
无论是传统的XML配置还是现代的注解方式，Spring都提供了丰富的工具和灵活性，以适应不同的开发需求。无论你是新手还是经验丰富的开发者，掌握Spring的核心特性都将极大地提升你的开发效率和代码质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值