Spring入門

時間  2019-12-06
標籤 spring 入門 欄目 Spring 简体版
原文   原文鏈接

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>java

        Construct Injection 依賴注入

  3. set注入

    1. 普通方法spring

      <!--外部注入-->
<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 "賣蘋果手機";  }}express

      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;
        }mvc

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

        @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-->
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程