IoC 和 AOP 扩展

最新推荐文章于 2025-02-23 16:15:55 发布
最新推荐文章于 2025-02-23 16:15:55 发布
阅读量277 收藏
点赞数 2
分类专栏： 学习笔记 文章标签： 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/MinSunshine/article/details/94783265
版权

1.依赖注入扩展

.1.1构造注入

 Spring通过setter访问器实现对属性的赋值行为被称为“设值注入”。Spring通过构造方法赋值的能力，称为构造注入。
示例：
1.编写一个简单的类，添加有参和无参构造

/**
 * Desc:测试实体类
 * createBy:
 * Date: 2019/7/6 0006 0:02
 */
public class EntityUser {
    private String name;
    private String age;

    public EntityUser() {
    }
    public EntityUser(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public void print(){
        System.out.println("姓名："+"年龄是："+age);
    }

 使用设值注入时，Spring通过JavaBean的无参构造方法实例化对象。当编写带参构造方法后，Java虚拟机不在提供默认的无参构造。为了保证使用的灵活性，最好添加一个无参构造。

2.在Spring的配置文件中将name属性和age属性以构造注入的方式赋值给EntityUser对象。代码如下：

  <bean id="entityUser" class="cn.kgc.Entity.EntityUser">
        <!--通过定义的有参构造为对象的属性name和age赋值-->
        <constructor-arg name="name" value="张三"/>
        <constructor-arg name="age" value="18"/>
    </bean>

经验：
1、一个<consturcotr-arg>元素表示构造方法的一个参数，且使用时不区分顺序，当构造方法的参数出现混淆、无法区分时，可以通过<consturcotr-arg>元素的index属性指定该参数的位置索引，索引从0开始。<consturcotr-arg>还提供了type属性用来指定参数的类型，避免字符串和基本数据类型的混淆。
2、构造注入的时效性好，在对象实例化时就得到所依赖的对象，便于在对象的初始化方法中使用依赖对象；但受于方法重载的形式，使用灵活性不足。设置注入使用灵活，但时效性不好。
3、Spring还提供了多种注入方式。

1.2 命名空间注入

 p 命名空间的特点是使用属性而不是子元素的形式来配置Bean的属性，从而简化Bean的配置。
使用p命名空间进行属性的注入需要添加P命名空间的声明。

直接量（基本数据类型、字符串）属性，使用方式如下：
语法 p:属性名 =“属性值”。

引用Bean的属性，使用方式如下：
语法 p:属性名-ref=“Bean的id”.
代码如下：

<?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"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

        http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop-4.0.xsd

        http://www.springframework.org/schema/util  http://www.springframework.org/schema/util/spring-util-4.0.xsd

        http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-4.0.xsd

        http://www.springframework.org/schema/p  http://www.springframework.org/schema/p/spring-p-4.0.xsd">

    <!--通过p命名空间注入属性值-->
    <bean id="entityUser" class="cn.kgc.Entity.EntityUser"
    p:name="张三" p:age="18" p:hobby-ref="hobby">
    </bean>

1. 3.注入不同数据类型

 Spring提供了不同的标签来实现各种不同类型参数的注入，这些标签对于设值注入和构造注入都适用。

1.注入直接量（基本数据类型、字符串）
 对于 基本数据类型及其包装类、字符串，除了可以使用value属性，还可以通过<value>子元素进行注入，

 <!--通过value属性注入-->
    <bean id="entityUser" class="cn.kgc.Entity.EntityUser">
        <property name="name">
            <value>张三</value>
        </property>
        <property name="age">
            <value>18</value>
        </property>
    </bean>

如果属性中包含了xml中的特殊字符（&、<、>、"、’），则注入时需要进行处理。通常可以采用两种办法：

一、使用<![CDATA[]]>标记或把特殊字符替换为实体引用。
二、使用实体引用放肆
XML中的五个实体引用：

符号实体引用
<&lt ;
>&gt ;
&& amp;
,& apos;
"&quot ;

2、引用其他Bean组件

 Spring中定义的Bean可以互相引用，从而建立以来关系，除了使用ref属性，还可以通过<ref>子元素实现。示例如下：

<bean id="hobby" class="cn.kgc.Hobby"/>
<bean id="entityUser" class="cn.kgc.Entity.EntityUser">
        <property name="name">
         <ref bean="hobby"/>
        </property>
    </bean>

<ref>标签中的bean属性用来指定要引用的Bean的id。除了bean属性，在介绍一个local属性的用法。代码如下

 <bean id="hobby" class="cn.kgc.Hobby"/>
    <bean id="entityUser" class="cn.kgc.Entity.EntityUser">
            <property name="name">
             <ref local="hobby"/>
            </property>
        </bean>

local属性和bean属性都是用力啊指定要引用的Bean的id.他们的区别在于，Spring的配置文件是可以拆分成多个的，使用local属性只能在同一个配置文件中检索Bean的id,而使用bean属性可以在其他配置文件中检索id.
3.使用内部Bean
ruguo yige Bean组件尽在移除使用，可以把它定义为内部Bean。示例代码如下：

<bean id="entityUser" class="cn.kgc.Entity.EntityUser">
			 <bean class="cn.kgc.Hobby"/>
</bean>

4.注入集合类型的属性
(1).List 对于List或数组类型的属性，可以使用<List>标签注入。示例代码如下：

<bean id="entityUser" class="cn.kgc.Entity.EntityUser">
			<property name="hobbies">
			<list>
				<value>篮球</value>
				<value>乒乓球</value>
			</list>
				</property>
</bean>

(2).Set
对于Set类型的属性，可以使用标签注入。示例如下：

<bean id="entityUser" class="cn.kgc.Entity.EntityUser">
    			<property name="hobbies">
    				<set>
    					<value>篮球</value>
    					<value>乒乓球</value>
    				</set>
    			</property>
    </bean>

(3).Map
对于Map类型的属性，可以使用一下方式注入：

 <bean id="entityUser" class="cn.kgc.Entity.EntityUser">
        <property name="hobbies">
            <map>
                <entry>key<value>football</value></entry>
                <value>足球</value>
                <entry>key<value>basketball</value></entry>
                <value>篮球</value>
            </map>
        </property>
    </bean>

（4）.Properties
对于Properties类型的属性，可以使用如下注入方式：

 <bean id="entityUser" class="cn.kgc.Entity.EntityUser">
        <property name="hobbies">
            <props>
                <prop key="football" >足球</prop>
                <prop key="basketBall">篮球</prop>
            </props>
        </property>
    </bean>

2 、其他增强类（异常抛出增强、最终增强、环绕增强）

2.1异常抛出增强：

 异常抛出增强的特点是在目标方法抛出异常是织入增强处理。使用异常抛出增强，可以为各功能模块提供同一个的、可以插拔的异常处理方案。
以下为异常抛出增强示例：

/**
 * Desc: 异常抛出增强类
 * createBy:
 * Date: 2019/7/6 0006 0:59
 */
public class ErrooLogger {
    
    private static final Logger log = Logger.getLogger(ErrooLogger.class);
    //增强方法
    public void afterThrowing(JoinPoint jp,RuntimeException e){
        log.error(jp.getSignature().getName()+"方法执行时发生异常："+e);
    }
}

Spring.xml配置文件中的代码如下：

 <!--声明异常方法所在的Bean-->
    <bean id="theLogger" class="cn.kgc.util.ErrooLogger">
    </bean>
    <!--配置切面-->
    <aop:config>
        <!--定义切入点-->
        <aop:pointcut id="errorPointcut" expression="execution(* cn.kgc.service.*.*(..))"/>
        
        <!--引用包含增强方法的Bean-->
        <aop:aspect ref="theLogger">
            <!--将afterthrowing（）方法定义为异常抛出增强并引用pointcut切入点-->
            <!--通过throwing属性指定为名为e的参数注入异常实例-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="errorPointcut" throwing="e"/>
        </aop:aspect>
        
    </aop:config>

2.2实现最终增强

 最终增强的特点是无论方法抛出异常还是正常退出，该增强都会别执行，类似于异常处理机制中的finally块的作用，一般用于释放资源。使用最终增强，就可以为各个功能模块提供统一的、可插拔方案。
示例代码如下：

/**
 * Desc: 定义包含最终增强的Bean
 * createBy:
 * Date: 2019/7/6 0006 1:10
 */
public class AfterLogger {
    private static final Logger log = Logger.getLogger(AfterLogger.class);
    
    public void afterLogger(JoinPoint jp){
        log.info(jp.getSignature().getName()+"方法执行完毕！");
    }
    
}

Sprign配置文件中的代码：

<!--声明异常方法所在的Bean-->
    <bean id="afterLogger" class="cn.kgc.util.AfterLogger">
    </bean>
    <!--配置切面-->
    <aop:config>
        <!--定义切入点-->
        <aop:pointcut id="afterPointcut" expression="execution(* cn.kgc.service.*.*(..))"/>

        <!--引用包含增强方法的Bean-->
        <aop:aspect ref="afterLogger">
          <aop:after method="afterLogger" pointcut-ref="afterPointcut"/>
        </aop:aspect>

    </aop:config>

2.3实现环绕增强

 环绕增强是功能最强大的增强处理，Sprign把目标方法的控制权全都交给了它。环绕增强在目标方法的前后都可以植入增强处理。在环绕增强处理中，可以获取或修改目标方法的参数、返回值，可以对他进行异常处理，甚至可以决定目标方法是否被执行。
实现环绕增强代码如下：

**
 * Desc:定义环绕增强类
 * createBy:卢智伟
 * Date: 2019/7/6 0006 1:16
 */
public class AroundLogger {
    private static final Logger log = Logger.getLogger(AroundLogger.class);

    public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {

        log.info("调用" + jp.getTarget() + "的" + jp.getSignature().getName() + "方法。方法入参是：" + Arrays.toString(jp.getArgs()));

        try {
            Object result = jp.proceed(); //执行目标方法并获得返回值
            log.info("调用" + jp.getTarget() + "的" + jp.getSignature().getName() + "方法。方法返回值是：" + result);
            return result;
        } catch (Throwable e) {
            log.error(jp.getSignature().getName() + "方法执行时发生异常：" + e);
            throw e;
        }
    }

}
 <!--声明环绕增强方法所在的Bean-->
    <bean id="aroundLogger" class="cn.kgc.util.AroundLogger">
    </bean>
    <!--配置切面-->
    <aop:config>
        <!--定义切入点-->
        <aop:pointcut id="afterPointcut" expression="execution(* cn.kgc.service.*.*(..))"/>

        <!--引用包含增强方法的Bean-->
        <aop:aspect ref="aroundLogger">
          <!--将aroundLogger()方法定义为环绕增强并引用pointcut切入点-->
            <aop:around method="aroundLogger" pointcut-ref="afterPointcut"/>
            
        </aop:aspect>

    </aop:config>

 使用<aop:around>元素可以定义环绕增强。通过为增强方法声明ProceedingJoinPoint类型的参数，可以获得连接点信息，所用方法与JoinPoint相同。ProceedignJoinPoint是JoinPoint的子接口，其不但封装了目标方法及其入参数组，还封装了呗代理的目标对象，通过它的proceed()方法可以调用真正的目标方法，从而达到对连接点的完全控制。

总结：增强的类型

增强类型描述
前置增强方法执行前增加处理方法
后置增强方法执行后插入增强处理
异常抛出增强方法发生异常时插入增强处理
最终增强不管方法的执行状态如何都会插入增强处理
环绕增强在方法的各个方面都插入增强，是最强大的增强处理方案

3、使用注解实现IoC

3.1注解定义Bean组件

 Springcong 2.0版本开始引入注解的配置方式，将Bean的配置信息和Bean实现类结合在一起，进一步减少了配置文件的代码量。
 我们可以在JavaBean中通过注解实现Bean组件的定义。其配置方式如下：

 /**
 * Desc: 用户操作接口
 * createBy:卢智伟
 * Date: 2019/6/30 0030 16:58
 */
@Component("userDao")
public interface UserDao {

    public int addUser_UserDao(User user);

}

上述代码通过注解定义了一个名为userDao的Bean。
@Componet(“userDao”)的作用与在XML配置文件中编写<bean id = “userDao” class=“cn.kgc.dao.UserDaoImpl”/>等效。

此外还有三种特殊的注解：

注解用途
@Repository用于标注Dao类
@Service用于标注业务类
@Contoroller用于标注控制器类

 使用特定的注解可以使组件的用途更加清晰，并且Spring在以后的版本中可能回为他们添加特殊的功能，所以推荐使用特定的注解来标注特定的实现类。

3.2 注解装配Bean组件

 Spring提供了@Autowried注解来实现Bean的装配。
示例代码如下：

@Service("userService")
public class UserServiceImpl implements UserService {
    /**
     * 定义注解装载配件
     */

    @Autowired
    private UserDaoImpl userDao;

    /**
     * 使用@Resource注解来实现组件的装配
     */
    @Resource(name="userDao")
    private UserDao userDao2;

    public void setUserDao2(UserDao userDao2) {
        this.userDao2 = userDao2;
    }

 以上代码通过@Service标注了一个业务Bean,并使用@Autowired为dao属性注入所依赖的对象，spring将注解对dao属性进行复制，此时类中可以省略属性相关的setter方法。
 @Autowired采用按类型匹配的方式为属性自动装配合适的依赖对象，即容器会查找和属性类型相匹配的Bean组件，并自动为属性注入。若容器中有一个以上类型匹配的Bean是，则可以使用@Qualifier指定所需的Bean名称。
@Service(“userServiceImpl”)
public class UserServiceImpl implements UserService {

 /**
     * 定义注解转载配件
     */

    @Autowired
    @Qualifier("userDao")
    private UserDaoImpl userDao;

    /**
     * 使用@Resource注解来实现组件的装配
     */
    @Resource(name="userDao")
    private UserDao userDao2;

    public void setUserDao2(UserDao userDao2) {
        this.userDao2 = userDao2;
    }

3.3 加载注解定义的Bean组件

 使用注解定义完Bean组件，接下来就可以使用注解的配置信息启动Spring容器。
如何启动Spring容器：首先在Spring配置文件中添加对context命名空间的声明，然后使用<context:componet-scan>标签扫毛注解标注的类。base-package属性指定需要扫描的基准包（多个包名间用逗号隔开）。Spring会扫描这些包中的所有类，获取Bean的定义信息。
示例代码如下；

<?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"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:p="http://www.springframework.org/schema/p"
       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-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--编写配置文件，使用注解配置信息启动spring容器-->
    <!--context 命名空间-component-scan命名空间的属性，base-package指定需要扫描的包，多个包用逗号隔开-->
    <context:component-scan base-package="com.kgc.dao,com.kgc.service"/>
</beans>

 补充：
 1、@Autowired也可以对方法的入参进行标注。也可用户构造方法，实现构造注入。不过这样的用法一般比较少，这里就不做详解了。
 2、使用@Autowired注解进行装配是，如果找不到相匹配的Bean组件，Spring容器就会抛出异常。此时如果依赖不是必需的，为避免抛出异常可以将required属性设置为false。如下所示：

 @Autowired(required = false);
    private UserDao userDao;

 需要注意的是required属性默认为true,即必须找到匹配的Bean完成装配，否则抛出异常。
 3、如果对类中集合类型的成员变量或方法入参使用@Autowired注解，Spring会将容器中所有和集合中元素类型匹配的Bean组件都注入进来。

3.4 使用@Resource注解实现组件装配

 除了提供@Autowired注解，Spring还支持使用JSR-250(JSR全称是：Java Specification Requests,Java规范提案)中定义的@Resource注解实现组件装配，该注解也能对类的成员变量或方法入参提供注入功能。
 @Resource有一个name属性，默认情况下，Spring将这个属性的值解释为要注入的Bean的名称，用法示例如下：

//为dao属性注入名为userDao的Bean
public class UserDaoImpl02 implements UserDao {
 
    //为dao属性注入名为userDao的Bean
    @Resource(name="userDao");
 
    private UserDao userDao;
    }

 如果没有显示的指定Bean的名称，@Resource注解将根据字段名或者setter方法名产生默认的名称：如果注解应用于字段，将使用字段名作为Bean的名称；如果注解应用于setter方法，Bean的名称就是通过setter方法得到的属性名。
 如果没有显示地指定Bean的名称，且无法找到与默认Bean名称相匹配的Bean组件，@Resource注解会有案名称查找的方式自动变为案类型匹配的方式进行装配。

4 使用注解实现AOP

4.1 认识AspectJ

 AspectJ是一个面向切面的框架，它扩展了Java语言、定义了AOP语法，能够在编译期提供代码的织人，它提供了一个专门的编译器用来生成遵守字节码规范的Class文件。
 
 Spring通过集成AspectJ实现了以注解的方式定义切面，大大减轻了配置文件的工作量。此外，因为Java的反射机制无法获取方法参数名，Spring还需要利用轻量的字节码处理框架asm(已经集成在Spring Core模块中)处理@AspectJ中所描述的方法参数名。

4.2 使用注解简化切面的配置

 使用注解前需要引入相应的命名空间aop,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"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

        http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop-4.0.xsd

        http://www.springframework.org/schema/util  http://www.springframework.org/schema/util/spring-util-4.0.xsd

        http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-4.0.xsd

        http://www.springframework.org/schema/tx  http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

        http://www.springframework.org/schema/p  http://www.springframework.org/schema/p/spring-p-4.0.xsd">
  
</beans>

接下来使用注解定义切面，以及插入相应的增强处理：

@Aspect
public class Logger_all {
    private Logger logger = Logger.getLogger(Logger_all.class);

    //定义前置增强方法
    @Before("execution(* main.java.cn.kgc.dao.impl.*.*(..))")
    public void before(JoinPoint jp){
       logger.info(("调用："+jp.getTarget()+"的"+jp.getSignature().getName()+"方法,方法的入参是："+ Arrays.toString(jp.getArgs())));
    }

    //定义后置增强方法
    @AfterReturning(pointcut = "execution(* main.java.cn.kgc.dao.impl.*.*(..)",
    returning = "result")
    public void after(JoinPoint jp,Object result){
       logger.info(jp.getTarget()+"类的"+jp.getSignature().getName()+"方法执行完毕,方法的返回值是："+result);
    }
}

以上各注解的作用：

注解用途
@Aspect定义切面
@Before定义前置增强方法
@After-Returning定义后置增强方法

 下面对这些注解做一些详细的解释：
 在上述示例中，使用@Aspect注解将UserServiceLogger定义为切面，并且使用@Before注解将before()方法定义为前置增强，使用@AfterRetuning注解将after()方法定义为后置增强。为了能够获取当前连接点的信息，在增强方法中添加了JoinPoint类型的参数，Spring会自动注入该实例。对于后置增强，还可以定义一个个参数用于接收该参数的名称，Spring会自动注入该实例。对于后置增强，还可以定义一个参数用于接收目标方法的返回值。需要注意的是，必须在@AfterRunting注解中通过returning属性指定该参数的名称，Spring会将目标方法的返回值赋值给指定名称的参数。

 而对于相同的切入点要求，可以统一定义，以便于重用和维护。
如下所示：

@Aspect
public class Logger_all {
    private Logger logger = Logger.getLogger(Logger_all.class);
	@Pointcut("execution(* main.java.cn.kgc.dao.impl.*.*(..))")    
	public void pointcut(){}
	
    //定义前置增强方法
    @Before("pointcut()")
    public void before(JoinPoint jp){
       logger.info(("调用："+jp.getTarget()+"的"+jp.getSignature().getName()+"方法,方法的入参是："+ Arrays.toString(jp.getArgs())));
    }

    //定义后置增强方法
    @AfterReturning(pointcut="pointcut()",
    returning = "result")
    public void after(JoinPoint jp,Object result){
       logger.info(jp.getTarget()+"类的"+jp.getSignature().getName()+"方法执行完毕,方法的返回值是："+result);
    }
}

 切入点表达式使用@Pointcut注解来标识，而切入点签名则需通过一个普通的方法定义来提供，如上述示例中的pointcut()方法，作为切入点签名的方法必须返回void类型，定义好切入点以后，就可以使用"pointcut()"签名进行引用。
 切面定义完后，还需要在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"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop-4.0.xsd

    http://www.springframework.org/schema/util  http://www.springframework.org/schema/util/spring-util-4.0.xsd

    http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-4.0.xsd

    http://www.springframework.org/schema/tx  http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

    http://www.springframework.org/schema/p  http://www.springframework.org/schema/p/spring-p-4.0.xsd">


    <!--扫描基准包中的注解-->
    <context:component-scan base-package="main.java.cn.kgc"/>
  
    <!--声明含有增强方法的Java Bean ，此处因为不需要被其他Bean引用所以不用指定id属性-->
    <bean class="main.java.cn.kgc.util.Logger_all"/>
   
    <!--启动切面的自动代理-->
    <aop:aspectj-autoproxy/>

 配置文件中<aop:aspectj-zuotoproxy>标签的作用：启动对于@AspectJ注解的支持，Spring将自动为匹配的Bean创建代理。

4.3 @AfterThrowing、@After和@Around注解的使用
 使用@AfterThrowing注解可以定义异常抛出增强。如果需要获取抛出的异常，可以为增强方法声明相关类型的参数，并通过@AfterThrowing的Throwing属性指定该参数名称，Spring会为其注入从目标方法抛出的异常实例。
示例如下：

@Aspect
public class ErrorLogger {
    Logger log = Logger.getLogger(ErrorLogger.class);

    //定义异常处理方法
    @AfterThrowing(pointcut = "execution(* main.java.cn.kgc.service.*.*(..))",throwing="e")
    public void afterThorwing(JoinPoint jp,RuntimeException e){
        log.info("执行："+jp.getTarget()+"的："+jp.getSignature().getName()+"时发生："+e+"异常");
    }
}

 使用@After注解可以实现最终增强：

@Aspect
public class AfterLogger {
    Logger logger = Logger.getLogger(AfterLogger.class);
    @After("execution(* main.java.cn.kgc.service.*.*(..))")
    public void afterLogger(JoinPoint jp){
        logger.info(jp.getTarget()+"类的:"+jp.getSignature().getName()+"方法执行结束。");
    }
}

… 使用@Around注解可以定义环绕增强。通过为增强方法声明ProceedingJoinPoint类型的参数，可以获得连接点信息。通过它的proceed()方法可以条用真正的目标方法，从而实现对连接点的完全控制。示例如下：

/**
 * @description: 通过注解实现环绕增强
 * @author: 
 * @date: 2019-07-05 11:12
 */
@Aspect
public class AroundLogger {
    Logger logger = Logger.getLogger(AfterLogger.class);
    
    @Around("execution(* main.java.cn.kgc.*.*(..))")
    public Object aroundLogger(ProceedingJoinPoint pjp) throws Throwable {
        //前置增强
        logger.info("调用"+pjp.getTarget()+"的"+pjp.getSignature().getName()+"方法,方法入参是："+ Arrays.toString(pjp.getArgs()));
        //异常处理增强
        try{
          Object result =  pjp.proceed(); //执行目标的方法
            logger.info("执行"+pjp.getTarget()+"的"+pjp.getSignature().getName()+"方法,方法入参是："+ Arrays.toString(pjp.getArgs())+"方法的返回值是："+result);

            //将执行的返回值返回
            return result;
        } catch(RuntimeException e){
            logger.error(pjp.getTarget()+"的"+pjp.getSignature().getName()+"方法执行时发生异常："+e);
         throw e;
        } finally {
            //最终增强
            logger.info(pjp.getTarget()+"的"+pjp.getSignature().getName()+"方法执行完毕。");
        }
    }
}

总结：
1、Spring 提供了设置注入、构造注入等依赖注入方式。
2、使用 p 命名空间可以简化属性注入的配置。
3、Spring 提供的增强处理类型包括前置增强、后置增强、异常抛出增强、环绕增强、最终增强等。
4、通过Schema 形式将 POJO 的方法配置成切面，所用标签包括：

标签作用
<aop:aspect>定义切面
<aop:before>定义前置增强处理
<aop:after_returning>定义后置增强处理
<aop:around>定义环绕增强处理
<aop:after-throwing>定义异常抛出增强处理
<aop:after>定义最终增强处理。

5、用来定义Bean组件的注解包括：

注解用途
@Component用于定义普通类
@Repository用于标注Dao类
@Service用于标注业务类
@Contoroller用于标注控制器类

 使用特定的注解可以使组件的用途更加清晰，并且Spring在以后的版本中可能回为他们添加特殊的功能，所以推荐使用特定的注解来标注特定的实现类。
6、Bean组件的装配可以通过@Autowired、@Qualifier以及@Resource实现。
7、在Spring配置文件中使用<context:component-scan>元素扫描包含注解的类，来完成初始化。
8、使用注解方法定义切面可以简化配置公国，常用的注解有：

注解作用
@Aspect定义切面
@Before定义前置增强处理
@AfterRunting定义后置增强处理
@Around定义环绕增强处理
@AfterThrowing定义异常抛出增强处理
@After定义最终增强处理。

9、在配置文件中添加<aop:aspectj-autoproxy>元素，就可以启用对于@AspectJ注解的支持。

“掌握Spring IoC和AOP：30道面试必备问题解析！“
私聊前往站内信：https://i.youkuaiyun.com/#/msg/chat/weixin_44976692
01-03 2万+
在面试过程中，Spring的IoC（控制反转）和AOP（面向切面编程）是被频繁问及的重要主题。掌握这两个核心概念和技术，对于成为一名优秀的Java开发者至关重要。本篇博客将为你提供一份包含20个关键问题的面试指南，助你在面试中游刃有余，展现出对Spring IoC和AOP的深刻理解。无论你是初学者还是有经验的开发者，这20个问题将覆盖IoC和AOP的核心知识点，帮你更好地准备面试。让我们一同深入探讨，揭秘Spring的IoC和AOP的奥秘，为你的面试之路加分不少！🚀💻。
狂神说Spring06：静态/动态代理模式
热门推荐
狂神说
04-21 1万+
狂神说Spring系列连载课程，通俗易懂，基于Spring最新版本，欢迎各位狂粉转发关注学习。禁止随意转载，转载记住贴出B站视频链接及公众号链接！代理模式为什么要学习代理模式，因为AOP...
Ioc和Aop的扩展
qq_36074163的博客
07-27 371
三．Ioc和Aop使用扩展 DI注入(设置注入/构造注入/p命名注入) 1.构造注入 第一步(类1)     (类二) 第二步：Xml文件 第三步：单测       3.(DI)注解 1.（小案例） 第一步：xml xml version="1.0" encoding="UTF-8"?> beans xmlns="http://
Spring中的IOC和AOP
最新发布
zenbior的博客
02-23 2113
Spring 框架是一款轻量级的开发框架，核心思想是 IOC(控制反转)和 AOP(面向切面编程)。为 Java 应用程序开发提供组件管理服，用于组件之间的解耦，以及简化第三方JavaEE中间件技术的使用(IMS、任务调度、缓存、ORM 框架)，是一个基础架构型的开发框架;。AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它允许开发者将横切关注点（如日志记录、事务管理、安全性等）从业务逻辑中分离出来。
IOC和AOP扩展
weixin_45496051的博客
08-06 382
IOC和AOP扩展IOC扩展构造注入（通过构造函数注入数据）p命名空间实现属性注入构造注入和设值注入对比注入不同参数带有特殊符号的值注入集合类型的属性注入null和空字符串值AOP扩展环绕增强 上一篇我们学习了IOC和AOP的基本概念，现在我们来深入了解一下。 IOC扩展 上一篇中使用Spring通过 setter访问器实现了对属性的赋值，这种做法称为设值注入。除此之外，Spring还提供了通过多种方式实现依赖注入。 构造注入（通过构造函数注入数据） 通过构造方法的赋值能力，称为构造注入。 示例： 类： p
IoC和AOP的扩展
chenjia的博客
06-12 445
前言 上一章我们学习了Spring框架的IoC和AOP的基本概念，这一章我们深入了解。 IoC扩展 多种方式实现依赖注入 上一篇中使用Spring通过 setter访问器实现了对属性的赋值，这种做法称为设值注入。除此之外，Spring还提供了通过构造方法的赋值能力，称为构造注入。 1. 构造注入（通过构造函数注入数据） （1） <constructor-arg>元素表示构造方法的一个...
65-IoC和AOP的扩展
weixin_44614066的博客
06-13 223
IoC和AOP的扩展 IoC：Inversion Of Control 控制反转 ​ 以前传统的获取某个类的实例需要自行进行创建，而现在对象的生命周期都交给Spring容器管理。 ​ 一个类依赖于另一个类对象(一个类有一个对象属性)，以前需要你自行创建对象属性然后注入，现在也都由Spring容器进行管理。 ​ 交给Spring管理之后，我们只需要关注需要谁即可，耦合性大大降低。 AOP：Aspe...
SpringIOC和AOP原理设计模式
01-27
Spring框架的核心特性主要体现在Spring的IOC（Inversion of Control，控制反转）和AOP（Aspect-Oriented Programming，面向切面编程）上。这两个概念在实际的软件开发中扮演着非常重要的角色，能够极大地提高代码的...
Spring核心IoC和AOP的理解
08-31
Spring核心IoC和AOP的理解 本文主要介绍了Spring核心IoC和AOP的相关知识，涵盖了IoC和AOP的概念、特点、优点和应用场景等方面的内容。...Spring框架的 IoC和AOP机制使得程序更加灵活、更加易于维护和扩展。
Spring IOC和aop的原理及实例详解
08-25
* 提高扩展性： IOC和AOP可以使得系统的扩展性提高，因为它们可以将逻辑代码分离出来，形成独立的模块。 结论 Spring IOC和AOP是两种非常重要的设计模式。它们可以使得系统的耦合度降低，提高可维护性和扩展性。...
C#实现的IOC和AOP框架，供学习
07-22
这样可以降低对象间的耦合度，使得系统更易于扩展和维护。在C#中，通常通过接口和抽象类来实现依赖注入，同时可以利用微软的Unity、Autofac或Ninject等第三方IOC容器来简化这一过程。IOC容器负责解析依赖关系，根据...
IoC 和 AOP 扩展 总结
JavaDarren的博客
08-12 396
本章总结 1.Spring 提供了设值注入、构造注入等依赖注入方式。 2.使用 p 命名空间可以简化属性注入的配置。 3.Spring 提供的增强处理类型包括前置增强、后置增强、异常抛出增强、环绕增强、最终 增强等，本章重点介绍后三种。 4.通过 Schema 形式将 POJO的方法配置成切面，所用标签包括<aop:aspect>、 <aop:before>、...
IoC和AOP使用扩展
qq_42007309的博客
09-28 326
1.构造注入 我们使用Spring通过setter访问器实现了对属性的赋值，这种做法被称为设值注入。设置注入是一种无参构造方法 &amp;lt;bean id=&quot;demo&quot; class=&quot;com_bdqn_cn.Demo&quot;&amp;gt; &amp;lt;property name=&quot;id&quot; value=&quot;1&quot;/&amp
IoC 及 AOP 使用扩展
m0_64681527的博客
09-22 331
JOP与AOP 扩展 以及JOP与AOP注解的使用。
ioc和aop拓展使用
qq_41867643的博客
09-28 235
使用Bean标签的注入方式 1.设置注入 &lt;bean id="author" class="aop.cn.Author"&gt; &lt;property name="name" value="魏琦琦"/&gt; &lt;property name="age" value="19"/&gt;
Spring——IoC和Aop使用拓展
秋风浮水的博客
09-27 3562
一、多种方式实现依赖注入 构造注入 设值注入 p命名空间注入 1、构造注入：通过构造函数注入数据。 构造注入的优劣势：构造注入的时效性好，在对象实例化时就得到所依赖的对象，便于在对象的初始化时就得到所依赖的对象，便于在对象的初始化方法中使用依赖对象；但受限于方法重载的形式，使用灵活性不足。 &lt;!-- 构造注入 --&gt; &lt;bean id="user" class="en...
IcO和AOP扩展
好人一生平安
09-11 491
依赖注入扩展 Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下： 谁控制谁，控制什么：传统Java SE程序...
理解Spring框架：IOC与AOP详解
Spring的IoC和AOP特性极大地提高了Java应用的可维护性和可扩展性，使得开发者能够专注于业务逻辑，而不是基础设施的细节。通过Spring，我们可以构建更干净、模块化的代码，从而提高软件的质量和开发效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值