Spring入门

Spring

• Spring
  • 下载
  • IOC
  • Construct Injection 依赖注入
  • AOP

  • Spring中的事务

    下载

1. 下载Spring包:spring下载
2. 导包:
   1. spring-beans-4.1.0.RELEASE.jar
   2. spring-context-4.1.0.RELEASE.jar
   3. spring-core-4.1.0.RELEASE.jar
      
   4. spring-expression-4.1.0.RELEASE.jar
3. 下载相关依赖包
   • commons-logging-1.1.1.jar

IOC

1. IOC对象相关参数
   1. scope="prototype" 多例 得到ICO容器后什么时候用什么时候创建
   2. scope="singleton" 单例 在得到IOC容器之前就已经创建好了
   3. init-method="init" 对象在创建的时候执行的初始化方法
   4. destroy-method="destroy" 对象在销毁的时候执行的销毁方法
   5. lazy-init="true" 延迟加载 true=延迟| false=不延迟 default=false
2. IOC对象创建
   1. 无参构造方法
      java <bean id="user1" class="pojo.User"></bean>
   2. 有参构造方法
      1. 普通赋值
         xml <bean id="user2" class="pojo.User">??? <property name="id" value="2"></property>??? <property name="username" value="李四"></property></bean>
      2. set赋值
         xml <bean id="user3" class="pojo.User">??? <constructor-arg value="1"> </constructor-arg>?? <constructor-arg value="张三"> </constructor-arg></bean>
   3. 工厂方法
      1. 静态工厂方法
         xml <bean id="user5" class="factory.Dfactory" factory-method="b"></bean>

      2. 普通工厂方法
         xml <bean id="c" class="factory.Dfactory"></bean><bean id="user4" factory-bean="c" factory-method="a"></bean>

         Construct Injection 依赖注入

3. set注入

   1. 普通方法

      <!--外部注入-->
      <bean id="userDao" class="com.Spring.dao.impl.UserDaoImpl">
       </bean>
       <bean id="userService" class="com.Spring.service.impl.UserServiceImpl">???
       <property name="userDao" ref="userDao"></property></bean>
      <bean id="userAction" class="com.Spring.controller.UserAction">???
       <property name="userService" ref="userService"></property></bean>

   2. 内部嵌套
      xml <!--内部注入--> <bean id="userAction" class="com.Spring.controller.UserAction">??? <property name="userService">????? <bean class="com.Spring.service.impl.UserServiceImpl">???????? <property name="userDao">?????? <bean class="com.Spring.dao.impl.UserDaoImpl"> </bean>??????????? </property>??????? </bean>??? </property> </bean>
   3. p命名空间
      • 引入xmlns:p="http://www.springframework.org/schema/p"

       <!--p命名空间注入-->
       <bean id="userDao" class="com.Spring.dao.impl.UserDaoImpl">                    </bean>
       <bean id="userService" class="com.Spring.service.impl.UserServiceImpl" p:userDao-ref="userDao"></bean>
       <bean id="userAction" class="com.Spring.controller.UserAction" p:userService-ref="userService"></bean>

   4. 自动装配:
      1. byName
         xml ?<!--自动装配 byName -->? <bean id="userDao" class="com.Spring.dao.impl.UserDaoImpl"></bean>??? <bean id="userService" class="com.Spring.service.impl.UserServiceImpl" autowire="byName"></bean>??? <bean id="userAction" class="com.Spring.controller.UserAction" autowire="byName"></bean>
      2. byType
         xml <!--自动装配 byType --> <bean id="userDao" class="com.Spring.dao.impl.UserDaoImpl"> </bean> <bean id="userService" class="com.Spring.service.impl.UserServiceImpl" autowire="byType"> </bean> <bean id="userAction" class="com.Spring.controller.UserAction" autowire="byType"></bean>
4. 注解

   1. 需要环境: 帮助文档搜索xmlns:context

        xmlns:context="http://www.springframework.org/schema/context"
        http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd   

      1. @Repository : dao层
      2. @Service : service层
      3. @Controller : controller层
      4. @Component : 普通注解
      5. @Resource : 对象注解

AOP

1. 代理 参考博客:三种代理模式
   • 接口
     java package com.Spring.test; /** * @Author Jamin <br> * @Date 2019/3/26 15:43 <br> * @Description 接口 */public interface SALE {? String sale(int money);}

   • 实现类
     java package com.Spring.test; /** * @Author Jamin <br> * @Date 2019/3/26 15:44 <br> * @Description * 目标对象 * */ public class Apple{? public String sale(int money) {?????? return "卖苹果手机";? }}

     1. 静态代理: 因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.

      package com.Spring.test;
     
         /**
         * @Author Jamin <br>
         * @Date 2019/3/26 15:47 <br>
         * @Description
         *
         *
         * 静态代理
         */
         public class AppleProxy implements SALE {
             private Apple apple = new Apple();
             public AppleProxy(Apple apple) {
                 this.apple = apple;
             }
     
             @Override
             public String sale(int money) {
     
                 String s=apple.sale(money);
                 String a="买手机送手机壳";
                 return s+a;
             }
         }
     

     1. 动态代理 需要给出代理对象的类型 需要给出代理对象接口的类型

            package com.Spring.test;
     
        import java.lang.reflect.InvocationHandler;
        import java.lang.reflect.Method;
        import java.lang.reflect.Proxy;
     
        /**
        * @Author Jamin <br>
        * @Date 2019/3/26 16:19 <br>
        * @Description
        */
        public class SaleFactory {
        private Object o;
     
        public SaleFactory(Object o) {
            this.o = o;
        }
     
        public Object factory() {
            return Proxy.newProxyInstance(
                o.getClass().getClassLoader(),
                o.getClass().getInterfaces(),
                new InvocationHandler() {
                /**
                *
                * @param proxy 被代理的对象
                * @param method  要调用的方法
                * @param args   方法调用时所需要的参数
                */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("aaaaaaaaaaaaaaa");
                    Object invoke = method.invoke(o, args);
                    System.out.println("bbbbbbbbbbbbbbb");
                    return invoke;
                }
                });
        }
        }
     

     1. Cglib代理 子类代理
        ```java
        package com.Spring.test;

        import org.springframework.cglib.proxy.Enhancer;
        import org.springframework.cglib.proxy.MethodInterceptor;
        import org.springframework.cglib.proxy.MethodProxy;

        import java.lang.reflect.Method;

        /**
        • @Author Jamin
          
        • @Date 2019/3/26 17:15
          
        • @Description
          */
          public class Cglib implements MethodInterceptor {
          private Object o;

        public Cglib(Object o) {
        this.o = o;
        }

        public Object getProxy() {
        Enhancer en = new Enhancer();
        en.setSuperclass(o.getClass());
        en.setCallback(this);
        return en.create();
        }

        @Override
        public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy)
        throws Throwable {
        System.out.println("aaaaaaaaaaaaa");
        Object invoke = method.invoke(o, objects);
        System.out.println("bbbbbbbbbbbb");
        return invoke;
        }
        }

        ```
2. AOP
   1. 概念:
      1. 是一种编程范式,不是一种编程语言
      2. 解决特定问题,不是解决所有问题
      3. 是OOP的补充,不是替代
   2. 好处:
      1. 集中处理某一关注点/横切逻辑
      2. 方便添加/删除关注点
      3. 侵入性少,增强代码可读性及可维护性
   3. 应用场景
      1. 权限控制
      2. 缓存控制
      3. 事务控制
      4. 审计日志
      5. 性能监控
      6. 分布式追踪
      7. 异常处理
   4. 名词解释
      1. 连接点
         • 目标对象中所有可以增强的方法
      2. 切入点
         • 目标对象中已经增强的方法
      3. 目标对象Target
         • 代理的目标对象(被代理的对象)
           
      4. 通知
         1. 目标方法在切面运行时的方法
         2. 通知类型
            1. 前置通知(before)
            2. 后置通知(after)
            3. 异常通知(after-throwing)
            4. 返回通知(after-returning)(异常不会执行)
            5. 环绕通知(around)
      5. 织入Weaving
         • 将通知应用到切入点的过程
      6. 代理Proxy
         • 将通知织入到目标对象之后形成的代理
   5. 使用
      1. 导包
         • com.springsource.org.aopalliance-1.0.0.jar
         • com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
         • spring-aspects-4.1.0.RELEASE.jar
      2. 创建目标对象
         
      3. 创建通知对象
      4. 将对象织入到目标对象中
      5. 配置切入点
      6. 指定通知
   6. 代码
      1. 第一种方式
         1. 配置文件
            xml <!--创建目标对象--> <bean id="empServiceImpl" class="com.spring.EmpService.EmpServiceImpl"></bean> <!--创建代理对象--> <bean id="empAop" class="com.spring.aop.EmpAop"></bean> <!--将对象织入目标对象中--> <aop:config> <!--配置切入点--> <aop:pointcut id="pt" expression="execution(* com.spring.EmpService.EmpServiceImpl.*())"></aop:pointcut> <!--指定通知--> <aop:aspect ref="empAop"> <aop:before method="getBefore" pointcut-ref="pt"></aop:before> <aop:after method="getAfter" pointcut-ref="pt"></aop:after> <aop:around method="getRound" pointcut-ref="pt"></aop:around> <aop:after-returning method="getReturn" pointcut-ref="pt"></aop:after-returning> <aop:after-throwing method="getThrowable" pointcut-ref="pt"></aop:after-throwing> </aop:aspect> </aop:config>

         2. 方法
            ```java
            package com.spring.aop;

             import org.aspectj.lang.ProceedingJoinPoint;
            
             /**
             * @Author Jamin <br>
             * @Date 2019/3/27 10:22 <br>
             * @Description
             */
             public class EmpAop {
            
             /** 前置通知 */
             public void getBefore() {
                 System.out.println("前置通知");
             }
             /*后置通知*/
             public void getAfter() {
                 System.out.println("后置通知");
             }
             /*环绕通知*/
             public Object getRound(ProceedingJoinPoint pj) throws Throwable {
                 System.out.println("环绕通知前");
                 Object proceed = pj.proceed();
                 System.out.println("环绕通知后");
                 return proceed;
             }
             /*返回通知*/
             public void getReturn() {
                 System.out.println("返回通知");
             }
             /*异常通知*/
             public void getThrowable() {
                 System.out.println("异常通知");
             }
             }

            ```
      2. 第二种方式 注解配置

         1. 配置文件

              <!--创建目标对象-->
              <bean id="empServiceImpl" class="com.spring.EmpService.EmpServiceImpl"></bean>
              <!--创建代理对象-->
              <bean id="empAop2" class="com.spring.aop.EmpAop2"></bean>
              <!--开启自动代理-->
              <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

         2. 方法

                          package com.spring.aop;
            
              import org.aspectj.lang.ProceedingJoinPoint;
              import org.aspectj.lang.annotation.*;
              import org.springframework.core.annotation.Order;
            
              /**
              * @Author Jamin <br>
              * @Date 2019/3/27 14:02 <br>
              * @Description
              */
              @Aspect
              public class EmpAop2 {
              @Pointcut("execution(* com.spring.EmpService.EmpServiceImpl.*())")
              public void pointCut() {}
            
              /** 前置通知 */
              @Before("pointCut()")
              public void getBefore() {
                  System.out.println("前置通知");
              }
            
              /*返回通知*/
              @AfterReturning("pointCut()")
              public void getReturn() {
                  System.out.println("返回通知");
              }
              /*后置通知*/
              @After("pointCut()")
              public void getAfter() {
                  System.out.println("后置通知");
              }
              /*环绕通知*/
              @Order(2)
              @Around("pointCut()")
              public Object getRound(ProceedingJoinPoint pj) throws Throwable {
                  System.out.println("环绕通知前");
                  Object proceed = pj.proceed();
                  System.out.println("环绕通知后");
                  return proceed;
              }
              /*异常通知*/
              @AfterThrowing("pointCut()")
              public void getThrowable() {
                  System.out.println("异常通知");
              }
              }

            Spring中的事务

3. 事务的概念
   • 事务是逻辑上的一组操作,要么都执行,要么都不执行
4. 事物的特征
   • 原子性:事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用；
   • 一致性:执行事务前后，数据保持一致；
   • 隔离性:并发访问数据库时，一个用户的事物不被其他事物所干扰，各并发事务之间数据库是独立的；
   • 持久性: 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。
5. 并发事务带来的问题
   1. 脏读[Dirty read] : 当一个事务正在访问数据并对事务进行了修改但并未提交,另一个事务也访问这条数据并使用了这条脏数据
   2. 丢失修改:两个事务同时访问一条数据并进行修改,第一个事务的修改结果就丢失了
   3. 不可重复读:一个事务多次读同一个数据,还没有结束时,第二个事务修改了这条数据导致第一个事务读到的数据不一致
   4. 幻读: 一个事务读取了几条数据,第二个事务添加了几条数据,导致第一个事务在随后的查询中发现了一些不存在的数据
      • 与不可重复读的区别:不可重复读的重点在修改,幻读的重点在于新增和删除
6. 解决读的问题
   • 设置隔离级别
7. Spring事务处理:声明式事务处理
   1. xml形式
      xml <!-- 定义事务管理器 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSources"/> </bean> <!--配置事务通知--> <tx:advice id="txadvice" transaction-manager="transactionManager"> <!--事务操作--> <tx:attributes> <tx:method name="account*"/> </tx:attributes> </tx:advice> <!--切面配置--> <aop:config> <!--切入点service层的实现方法--> <aop:pointcut id="pt" expression="execution(* com.springmvc.*())"/> <!--切面--> <aop:advisor advice-ref="txadvice" pointcut-ref="pt"></aop:advisor> </aop:config>

   2. 注解

               <!-- 定义事务管理器 -->
       <bean id="transactionManager"
           class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
           <property name="dataSource" ref="dataSources"/>
       </bean>
       <!--开启注解事务管理-->
       <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
       <!--在需要事务管理的方法上添加注解 @Transactional-->

Spring入门

原文：https://www.cnblogs.com/JaminYe/p/10630720.html