Spring总结

spring框架是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。通过把传统的new创建对象的权限上交,由配置文件统一管理对象,在配置文件中使用bean标签创建对象,调用时由工厂对象getBean(bean标签id)方法获取对象,具有低耦合的特点。

IOC

ioc也叫依赖注入(DI)是控制反转,意思为获得依赖对象的过程被反转了,利用依赖关系注入的方式,实现对象之间的解耦。

IOC给对象赋值有三种方法,分别为设置注入,构造注入和自动装配。

设置注入(底层实现是set方法)

在对象中不包含其他对象属性时,可以直接在bean标签内直接使用property标签的name和value属性设值。

<bean id="user" class="com.gxy.entity.User">
        <property name="name" value="张三"></property>
        <property name="age" value="20"></property>
        <property name="gender" value="男"></property>
    </bean>

在对象中包含其他对象属性时,需要创建所包含的对象属性的对象并赋值,然后在bean标签内使用property标签的name和ref属性设置,ref属性的值是所包含对象属性的bean标签id。

<bean id="user" class="com.gxy.entity.User">
        <property name="name" value="张三"></property>
        <property name="age" value="20"></property>
        <property name="gender" value="男"></property>
        <property name="commodity" ref="Commodity"></property>
    </bean>
    <bean id="Commodity" class="com.gxy.entity.Commodity">
        <property name="product" value="手机"></property>
        <property name="price" value="5999"></property>
    </bean>

构造注入(底层实现是构造方法)

在对象中不包含其他对象属性时,可以直接在bean标签内使用标签,再在constructor-arg标签内使用value标签设值,按照有参构造中参数的顺序一一设值。

<bean id="user" class="com.gxy.entity.User">
        <constructor-arg>
            <value>张三</value>
        </constructor-arg>
        <constructor-arg>
            <value>23</value>
        </constructor-arg>
        <constructor-arg>
            <value>男</value>
        </constructor-arg>
    </bean>

在对象中包含其他对象属性时,可以在标签内使用bean标签创建该对象属性的对象并赋值

 <bean id="user" class="com.gxy.entity.User">
        <constructor-arg>
            <value>张三</value>
        </constructor-arg>
        <constructor-arg>
            <value>23</value>
        </constructor-arg>
        <constructor-arg>
            <value>男</value>
        </constructor-arg>
        <constructor-arg>
            <bean id="commodity" class="com.gxy.entity.Commodity">
                <property name="product" value="手机"></property>
                <property name="price" value="5999"></property>
            </bean>
        </constructor-arg>
    </bean>

自动装配注入(底层实现是set方法)

自动装配无需在bean标签内写其所包含的其他对象的值,在bean标签内使用autowire属性,属性值为byName时会自动找到id和属性名一样的bean标签进行赋值

<bean id="user" class="com.gxy.entity.User" autowire="byName">
        <property name="name" value="张三"></property>
        <property name="gender" value="男"></property>
        <property name="age" value="23"></property>
    </bean>

    <bean id="commodity" class="com.gxy.entity.Commodity">
        <property name="product" value="手机"></property>
        <property name="price" value="5999"></property>
    </bean>

在bean标签内使用autowire属性,属性值为byType时会自动找类型和对象属性类型一样的bean标签进行赋值。

<bean id="user" class="com.gxy.entity.User" autowire="byType">
    <property name="name" value="张三"></property>
    <property name="gender" value="男"></property>
    <property name="age" value="23"></property>
</bean>

    <bean class="com.gxy.entity.Commodity">
        <property name="product" value="手机"></property>
        <property name="price" value="5999"></property>
    </bean>

AOP

aop通俗来说就是在不改变主干功能源代码的情况下,在主干功能里加入新的功能,Spring Aop底层是动态代理。

增强原理:在测试类调用目标方法之前已经加载了配置文件 ,加载配置文件会创建出所有的bean标签的对象。在调用目标方法时,由配置文件的编织后,去执行增强类,用代理模式,增强类可以拿到目标类的实参和方法名以及类路径和返回值类型。增强类根据所实现的接口去执行,前置增强是执行完毕增强方法后,再执行对应的目标方法,后置增强就是先执行目标方法后再执行增强方法。环绕增强在执行目标前后都会执行。环绕增强要使用methodInvocation.proceed()方法执行目标功能。

aop增强原则:增强功能不能影响核心功能。

前置增强和后置增强

首先创建增强类,前置增强实现MethodBeforeAdvice接口,后置增强实现implements接口,然后编写增强功能方法。

/**
 * Created by Zhu on 2021/4/25.
 * 前置增强类
 */
public class MyMet implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] objects, @Nullable Object o) throws Throwable {
        System.out.println("增强,执行之前输出");
    }
}
/**
 * Created by Zhu on 2021/4/26.
 * 后置增强
 */
public class MyAfterAdvice implements AfterReturningAdvice {
    @Override
    public void afterReturning(@Nullable Object o, Method method, Object[] objects, @Nullable Object o1) throws Throwable {
        System.out.println("增强,后置增强,执行后输出");
    }
}

在总配置文件内创建增强方法和目标方法的对象。然后使用标签定义aop配置,定义切入点,将增强类和切点编织,当代码执行过程中,执行到切点时会根据增强类实现的接口不同而先后执行。

  <!--创建前置增强类对象-->
    <bean id="MyMet" class="com.gxy.enhance.MyMet"></bean>
    <!--创建后置增强类对象-->
    <bean id="MyAftAd" class="com.gxy.enhance.MyAfterAdvice"></bean>

<aop:config>
    <!--定义切入点-->
        <aop:pointcut id="MyPointCut" expression="execution(* com.gxy.servlet.testprint.one(..))"></aop:pointcut>
        <!--编织-->
        <aop:advisor advice-ref="MyMet" pointcut-ref="MyPointCut"></aop:advisor>
        <aop:advisor advice-ref="MyAftAd" pointcut-ref="MyPointCut"></aop:advisor>
    </aop:config>

异常增强

首先创建增强类,实现ThrowsAdvice接口,然后编写增强功能方法。

/**
 * Created by Zhu on 2021/4/26.
 * 异常增强
 */
public class MyThrowsAdvice implements ThrowsAdvice {

    public void afterThrowing(Method menthod,Object[] args,Object target,Exception ex){

        System.out.println(target+"里的"+menthod.getName()+"产生了"+ex.getMessage());

    }
}

在总配置文件内创建增强方法和目标方法的对象。然后使用标签定义aop配置,定义切入点,将增强类和切点编织,当代码执行过程中遇到异常时,会执行增强类。

<!--创建异常增强类对象-->
    <bean id="ex" class="com.gxy.enhance.MyThrowsAdvice"></bean>

  <!--异常增强aop配置-->
    <aop:config>
        <!--定义切入点-->
        <aop:pointcut id="MyPointCut2" expression="execution(* com.gxy.servlet.testprint.ex(..))"></aop:pointcut>
        <!--编织-->
        <aop:advisor advice-ref="ex" pointcut-ref="MyPointCut2"></aop:advisor>
    </aop:config>

环绕增强

首先创建增强类,实现MethodInterceptor接口,然后编写增强功能方法,环绕增强要使用methodInvocation.proceed()方法执行目标功能,否则不会执行原目标功能。

/**
 * Created by Zhu on 2021/4/27.
 * 环绕增强
 */
public class MyInterceptor implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("环绕增强");
        Object object=methodInvocation.proceed();
        return object;
    }
}

再创建Annonation,使用Annonation注解完成定义切点。

/**
 * Created by Zhu on 2021/4/27.
 */
public @interface AnnonationTest {
}
 @AnnonationTest
    public int hr(){
        System.out.println("环绕增强核心功能");
        return 1;
    }

在总配置文件内创建增强方法和目标方法的对象。然后使用标签定义aop配置,定义切入点,将增强类和切点编织,当代码执行到切点时,会在切点之前的前后都执行增强类。

 <!--创建环绕增强类对象-->
    <bean id="hr" class="com.gxy.enhance.MyInterceptor"></bean>

 <!--环绕增强aop配置-->
    <aop:config>
        <!--定义切入点-->
        <aop:pointcut id="MyPointCut3" expression="@annotation(com.gxy.enhance.AnnonationTest)"></aop:pointcut>
        <!--编织-->
        <aop:advisor advice-ref="hr" pointcut-ref="MyPointCut3"></aop:advisor>
    </aop:config>

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值