Spring总结

最新推荐文章于 2024-06-19 20:53:45 发布

j803

最新推荐文章于 2024-06-19 20:53:45 发布

阅读量59

点赞数

分类专栏：总结文章标签： spring java

本文链接：https://blog.csdn.net/a759248/article/details/116135055

版权

总结专栏收录该内容

4 篇文章 0 订阅

订阅专栏

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>

j803

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring总结

spring框架是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。通过把传统的new创建对象的权限上交，由配置文件统一管理对象，在配置文件中使用bean标签创建对象，调用时由工厂对象getBean(bean标签id)方法获取对象，具有低耦合的特点。IOCioc也叫依赖注入(DI)是控制反转，意思为获得依赖对象的过程被反转了,利用依赖关系注入的方式，实现对象之间的解耦。IOC给对象赋值有三种方法，分别为设置注入，构造注入和自动装配。设置注入(底层实现是set方法)在对象中不包
复制链接

扫一扫