关于spring的简概

一、Spring入门操作

IOC
创建对象

<bean id="user" class="com.itheima.domain.User"></bean>
=
User user = new com.itheima.domain.User();

创建对象的三种方式

1.无参构造函数创建独享
2.静态工厂创建对象
    工厂类：com.itheima.factory.BeanFactory
        静态方法：public static User createUser(){}
    创建对象
    <bean class="com.itheima.factory.BeanFactory" factory-method="createUser" />

3.普通工厂创建对象
    工厂类：com.itheima.factory.BeanFactory
        非静态方法：public User createUser(){}
        
    创建工厂对象
    <bean id="beanFactory" class="com.itheima.factory.BeanFactory" />
    
    创建对象
    <bean factory-bean="beanFactory" factory-method="createUser" />

工厂对象

能够创建对象的类，称之为工厂类。
静态工厂
    创建对象的方法属于静态方法

普通工厂
    创建对象的方法属于非静态方法

依赖注入

1.属性注入--->调用set方法
2.构造注入--->调用带参构造函数
3.注解注入  @Autowired、@Resource、@Value

依赖注入的三种方式代码

  <!--
    1.属性注入:调用set方法赋值(要求对应的属性必须有set方法)
  -->
    <bean id="accountService" class="com.bky.service.impl.AccountServiceImpl">
        <!--
            property:表示使用属性注入
            调用setName给name赋值
            name="":表示要调用的set方法,省略set，第一个字母小写
            value="小红红":赋值，value只针对基本数据类型和字符串
        -->
        <property name="name" value="小明" />

        <!--
            age
        -->
        <property name="age" value="22" />

        <!--
            birthday
            ref="date":如果要赋值的数据是一个Bean 对象，则使用ref引用
        -->
        <property name="birthday" ref="date" />
    </bean>

    <!--
        Date date = new java.util.Date()
    -->
    <bean id="date" class="java.util.Date"></bean>


    <!--
        构造函数注入
    -->
    <bean id="accountService2" class="com.bky.service.impl.AccountServiceImpl">
        <!--
            构造函数注入
            name="指定构造函数的入参名字"
        -->
        <constructor-arg name="name" value="小王" />
        <constructor-arg name="age" value="25" />
        <constructor-arg name="birthday" ref="date" />
    </bean>

    <!--
        使用构造函数注入
            指定下标
    -->
    <bean id="accountService3" class="com.bky.service.impl.AccountServiceImpl">
        <constructor-arg index="2" ref="date" />
        <constructor-arg index="0" value="小牛" />
        <constructor-arg index="1" value="26" />
    </bean>

    <!--
        使用构造函数注入
            指定数据类型
    -->
    <bean id="accountService4" class="com.bky.service.impl.AccountServiceImpl">
        <constructor-arg type="java.lang.String" value="小明"/>
        <constructor-arg type="java.lang.String" value="深圳"/>
        <constructor-arg type="java.lang.Integer" value="27" />
        <constructor-arg type="java.util.Date" ref="date"/>
    </bean>
　　　　使用注解注入

@Autowired ：优先选择类型注入，如果类型相同，选择名字注入(by type)
@Resource　 :优先选择名字注入，如果名字相同，选择类型注入 (by name)
@Value :用于配置文件

二、Spring的相关注解

创建对象 :4个注解作用一样，用于创建对象
@Component() 如果不写名字，id值默认=类名，第一个字母小写

@Component： 一般用于普通对象
@Controller：一般用于表现层的注解。
@Service：   一般用于业务层的注解。
@Repository：一般用于持久层的注解。

@Bean:创建对象

作用在方法上，可以将方法的返回值交给SpringIOC容器管理

测试

@RunWith(SpringJUnit4ClassRunner.class) //创建测试容器，JUnit的扩展
@ContextConfiguration()    //指定配置文件或者配置类

三、AOP

AOP概念-->面向切面-->

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，
对我们的已有方法进行增强。

AOP的底层原理：动态代理技术

/***
 * 基于动态代理改造
 * 动态代理：
 *      特点：字节码随用随创建，随用随加载
 *      分类：基于接口的动态代理，基于子类的动态代理
 *      作用：不修改源码的基础上对方法增强
 *      基于接口的动态代理：
 *          提供者是：JDK官方
 *          使用要求：被代理类最少实现一个接口。
 *          涉及的类：Proxy
 *          创建代理对象的方法：newProxyInstance
 *          方法的参数：
 *              ClassLoader：类加载器。用于加载代理对象的字节码。和被代理对象使用相同的类加载器。固定写法。
 *              Class[]：字节码数组。用于给代理对象提供方法。和被代理对象具有相同的方法。和被代理对象实现相同的接口，就会具有相同的方法。固定写法
 *              InvocationHanlder：要增强的方法。此处是一个接口，我们需要提供它的实现类。通常写的是匿名内部类。
 *              增强的代码随用随写。
 */
ProxyProducer proxyProducer = (ProxyProducer) Proxy.newProxyInstance(
        Producer.class.getClassLoader(),
        Producer.class.getInterfaces(),
        new InvocationHandler() {
            /**
             * 执行被代理对象的任何方法都都会经过该方法，该方法有拦截的作用
             * 参数的含义
             *     Object proxy：代理对象的引用。一般不用
             *  Method method：当前执行的方法
             *  Object[] args：当前方法所需的参数
             * 返回值的含义
             *     和被代理对象的方法有相同的返回值
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //方法参数
                Float money = (Float) args[0];

                //获取方法名字
                String methodName = method.getName();

                //定义一个对象，存储返回结果
                Object result = null;

                //销售提成25%
                if(methodName.equals("saleProduct")){
                    result= method.invoke(producer,money*0.75f);
                }else if(methodName.equals("saleProduct")){
                    //销售提成10%
                    result= method.invoke(producer,money*0.9f);
                }
                return result;
            }
        }
);

AOP通知/增强

前置增强：目标方法执行前，执行增强操作(调用其他方法)
后置增强：目标方法执行完成后(return后)，执行增强
异常增强：目标方法执行发生异常后执行增强
最终增强：目标方法执行，无论是否发生异常，都会执行
环绕增强：模拟了动态的整个执行过程，可以做到前置增强、
        后置增强、异常增强、最终增强，还可以修改返回数据

声明式事务:基于AOP

1.配置数据源
2.配置事务管理器
3.配置事务管理规则[事务传播特性]
4.建立通知，指定执行事务控制的切点

猜你喜欢