1. 程式人生 > >超詳細Spring入門講解

超詳細Spring入門講解

1.基本內容

  • spring是為了解決企業應用開發的複雜性而建立的,是一個輕量級的控制反轉(IoC)[指的是將物件的建立權反轉給Spring,作用是實現了程式的解耦合]和麵向切面(AOP)的容器框架。
  • 並不侷限於某一層,是物件的容器,幫我們“管理”專案中所有的物件

2.操作

2.1快速入門

  • 架包結構
docs:API和開發規範 
libs:包  --> .jar包  javadoc.jar 文件  sources.jar 原始碼
schema:約束
  • 1.導包

日誌包

com.springsource.org.apache.commons.logging
-1.1.1.jar

可選日誌包(老版本)

com.springsource.org.apache.log4j-1.2.15.jar
  • 2.建立一個物件
package com.sjtu.bean;
public class User {
    private  String name;
    private Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public
Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } }
  • 3.書寫配置註冊物件到容器

    • 建立xml檔案,建議放在src下,檔名建議applicationContext.xml

    • 匯入約束

    • Preference–>XML Catalog–>Add–>FileSystem–>Spring目錄下的Schema–>beans–>選擇最新版

    • 在 Add XML Catalog Elementy頁面 ,key type選擇Schema location,key後面加上剛才新增的檔名。(意義是eclipse單機情況下也能找到該約束)

    • 在applicationContext.xml頁面加入<beans></beans> ,然後點選左下角的Design,選中beans,右鍵Edit namespaces ,新增xsi 檔案xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance",再點add,選擇Specify New Namespace ,選擇Browse ,選擇 Select XML Catalog entry ,選擇剛才匯入的 http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ,Namespace Name 為http://www.springframework.org/schema/beans ,Prefix為空

    • 配置xml檔案
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
    <!--將User物件交給spring容器管理  ,其中name任意,class為全包名-->
    <bean name="user" class="com.sjtu.bean.User"></bean>
    </beans>
  • 4.程式碼測試

@Test
public void fun1() {
  //1.建立容器物件,相對於src下的路徑
  ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
  //2.向容器“要”user物件
  User u=(User) ac.getBean("user");
  //3.列印user物件
  System.out.println(u);
}

3.概念

3.1IOC&DI

  • IOC

  • DI:

3.2applicationContext&BeanFactory

  • BeanFactory 介面
    • spring原始介面.最底層的介面。針對原始介面的實現類功能較為單一
    • BeanFactory介面實現類的容器.特點是每次在獲得物件時才會建立物件,為了節省記憶體
  • ApplicationContext
    • 每次容器啟動時就會建立容器中配置的所有物件.並提供更多功能
    • 從類路徑下載入配置檔案:ClassPathXmlApplicationContext
    • 從硬碟絕對路徑下載入配置檔案:FileSystemXmlApplicationContext(“d:/xxx/yyy/xxx”)

結論:web開發中,使用applicationContext. 在資源匱乏的環境(手機)可以使用BeanFactory.

4.配置詳解

4.1Bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
    <!--將User物件交給spring容器管理  ,其中name任意,class為全包名
        class屬性:被管理物件的完整類名
        name屬性:給被管理的物件起個名字,根據該名稱獲得物件
            可以重複,可以使用特殊字元
        id屬性:與name屬性一模一樣
            名稱不可重複,不能使用特殊字元
        結論:儘量使用name屬性
    -->
    <bean name="user" class="com.sjtu.bean.User"></bean>
</beans>

4.2Spring建立物件的三種方式

  • 1.空參構造方式(最主要方式)
<!--建立方式1:空參構造建立  -->
 <bean name="user" class="com.sjtu.bean.User"></bean>
//1.建立容器物件,相對於src下的路徑
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
  • 2.靜態工廠(瞭解)
public static User createUser() {
        System.out.println("靜態工廠建立User");//表示由使用者自己建立
        return new User();
    }
<!--建立方式2:靜態工廠建立方式  
        呼叫UserFactory的createUser方法建立名為user2的物件,放入容器
    -->
    <bean name="user2" 
        class="com.sjtu.b_create.UserFactory"  //類的全包名
        factory-method="createUser"></bean>     //類的方法
//測試
public void fun2() {
ApplicationContext ac=new ClassPathXmlApplicationContext("com/sjtu/b_create/applicationContext.xml");
//2.向容器“要”user物件
User u=(User) ac.getBean("user2");
    }
  • 3.例項工廠(瞭解)
public  User createUser2() {//不是靜態方法
        System.out.println("例項工廠建立User");
        return new User();
    }
    <!--建立方式3:例項工廠建立
            呼叫UserFactory物件的createUser2方法建立名為user3的物件,放入容器
          -->
    <bean name="user3" 
        factory-bean="userFactory"
        factory-method="createUser2"></bean>
    <bean name="userFactory" 
        class="com.sjtu.b_create.UserFactory" ></bean>
public void fun3() {
        ApplicationContext ac=new ClassPathXmlApplicationContext("com/sjtu/b_create/applicationContext.xml");
        //2.向容器“要”user物件
        User u=(User) ac.getBean("user3");

    }

4.3 Bean元素進階

4.3.1 scope屬性
  • singleton(預設值):單例物件,被標識為單例的物件在spring容器中只會存在一個例項
<bean name="user" class="com.sjtu.bean.User" scope="singleton"></bean>
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
//2.向容器“要”user物件
User u=(User) ac.getBean("user");
User u2=(User) ac.getBean("user");
User u3=(User) ac.getBean("user");
User u4=(User) ac.getBean("user");
//3.列印user物件 會發現只有一個例項
System.out.println(u==u3);
System.out.println(u2==u4);
  • prototype:多例原型,被標識為多例的物件,每次再獲得時才會獲得物件,每次都是新的的物件。整合Struts時,ActionBean必須配置為多例。
  • request:web環境下,物件與request生命週期一致 (瞭解)
  • session:web環境下,物件與session生命週期一致 (瞭解)
4.3.2生命週期屬性(瞭解)
  • 配置一個方法作為生命週期初始化方法.spring會在物件建立之後立即呼叫.
    • init-method
  • 配置一個方法作為生命週期的銷燬方法.spring容器在關閉並銷燬所有容器中的物件之前呼叫.
    • destory-method
<bean name="user" class="com.sjtu.bean.User" scope="singleton" init-method="init" destroy-method="destroy"></bean>
//並在User中實現此方法
public void init() {
        System.out.println("初始化");
    }

    public void destroy() {
        System.out.println("銷燬");
    }

4.4分模組配置

主配置檔案引入其他配置檔案

//在主配置檔案中做如下配置
<import resource="com/sjtu/b_create/applicationContext.xml"/>

4.5.屬性注入

屬於配置方法

  • set方法注入(重要)(前提是set注入之前該物件提供setter方法)
<bean name="user" class="com.sjtu.bean.User" >
    <!--值型別注入:為User物件中名為name的屬性注入tom作為值-->
    <property name="name" value="tom"></property>
    <property name="age" value="18"></property>
    <!--引用型別注入:為car屬性注入下方配置的car物件   car是user中一個物件-->
    <property name="car" ref="car"></property>
  </bean>
  <!--將car物件配置到容器中 -->
  <bean name="car" class="com.sjtu.bean.Car">
    <property name="name" value="蘭博基尼"></property>
    <property name="color" value="黃色"></property>
</bean>
  • 建構函式注入

    • 準備帶有引數的構造

    • <bean name="user2" class="com.sjtu.bean.User">
          <!-- name屬性:建構函式引數名 -->
          <!-- index屬性:建構函式引數索引  -->
          <!-- type屬性:建構函式引數型別 -->
          <!-- 上述三個屬性不必全部出現,根據情況選擇即可 -->
          <constructor-arg name="name"  value="Jerry" index="0" type="java.lang.String"></constructor-arg>
          <constructor-arg name="car" ref="car"></constructor-arg>
      </bean>

  • p名稱空間注入(瞭解)

<!-- p空間注入   走set方法
        1.匯入p空間名稱 xmlns:p="http://www.springframework.org/schema/p"
        2.使用p:屬性完成注入
            |-值型別 : p:屬性名="值"
            |-物件型別:p:屬性名-ref="bean名稱"
      -->
    <bean name="user3" class="com.sjtu.bean.User"    p:name="jack" p:age="20" p:car-ref="car">  
    </bean>

<!--car物件-->
<!--將car物件配置到容器中 -->
    <bean name="car" class="com.sjtu.bean.Car">
        <property name="name" value="蘭博基尼"></property>
        <property name="color" value="黃色"></property>
    </bean>
  • spel注入(瞭解)

    <!-- spel注入:Spring Expression Language  spring表示式語言-->
    <bean name="user4" class="com.sjtu.bean.User" >
        <property name="name" value="#{user.name}"></property>
        <property name="age" value="#{user3.age}"></property>
        <property name="car" ref="car"></property>
    </bean>

4.6複雜型別注入

  • 陣列,list,map等等
public class CollectionBean {
    private Object[] arr;//陣列型別注入
    private List list;//list/set型別注入
    private Map map;//map注入
    private Properties prop;// Properties 型別注入
}
  • 陣列
<bean name="cb"  class="com.sjtu.c_injection.CollectionBean">
        <!-- 如果陣列中只准備一個值(物件),直接使用value|ref即可 -->
        <!-- 物件中陣列名為arr -->
        <!-- <property name="arr" value="Tom"></property> -->
        <property name="arr">
            <array>
                <value>tom</value>
                <value>jerry</value>
                <ref bean="car"/>
            </array>
        </property>
</bean>
  • list
<!-- 如果list中只准備一個值(物件),直接使用value|ref即可 -->
        <!-- <property name="list" value="Tom"></property> -->
        <property name="list">
            <list>
                <value>tom</value>
                <value>Jerry</value>
                <ref bean="car"/>
            </list>
        </property>
  • map
<property name="map">
            <map>
                <entry key="1" value="abc"></entry>
                <entry key="2" value="def"></entry>
                <entry key-ref="car" value-ref="car"></entry>
            </map>
        </property>
  • prop
<property name="prop">
            <props>
                <prop key="abc">abc</prop>
                <prop key="def">def</prop>
                <prop key="ghi">ghi</prop>
            </props>
        </property>

5.整合web專案

6.使用註解配置spring

6.1步驟

  • 1.為主配置檔案引入新的名稱空間(約束)

    • 加入context,和之前快速入門完全一樣,只是在新增namespace時,prefix不能為空。
    • 匯入spring下的aop包
  • 2.開啟使用註解代替配置檔案

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd ">
    <!-- 指定掃描com.sjtu.bean包下的所有類中的註解
        注意:掃描包時,會掃描指定包下的所有子孫包 -->
    <context:component-scan base-package="com.sjtu.bean"></context:component-scan>
</beans>
  • 3.類中完成註解配置
@Component("user") //這四個註解完全一樣,以下三個只是為了分層
    @Service("user")  //Service層
    @Controller("user")  //Web層
    @Repository("user")  //Dao層
public class User {
}
  • 4.程式碼測試
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
User u=(User) ac.getBean("user");
System.out.println(u);

6.2其他註解說明

  • scope
//指定物件作用範圍
@Scope(scopeName="prototype")
public class User {}
  • 值注入型別
//方法一
@Value("Tom")
//加到成員變數上,通過反射的Field賦值,破壞封裝性
private  String name;
//方法二
@Value("Tom")
//通過set方法賦值
public void setName(String name) {
  this.name = name;
}
  • 引用型別引入

    @Autowired//自動裝配
    //問題,如果匹配多個型別一致的物件,將無法選擇具體注入哪一物件
    @Qualifier("car")//使用@Qualifier註解告訴spring容器自動裝配哪個名稱的物件
    public Car car;
    @Resource(name="car") //手動注入,指定注入哪個名稱的物件
    public Car car;
    
    @Component("car")
    public class Car {
    @Value("法拉利")
    private String name;
    @Override
    public String toString() {
        return "Car [name=" + name + "]";
    }
    }

  • 初始化、銷燬方法

    @PostConstruct //在物件被建立之後呼叫,init-method
    public void init() {
        System.out.println("初始化");
    }
    @PreDestroy //在物件銷燬之前呼叫,destroy-method
    public void destroy() {
        System.out.println("初始化");
    }

7.STS外掛

8.spring與junit整合測試

  • 導包(4+2+aop+test)
  • 配置註解
//建立容器
@RunWith(SpringJUnit4ClassRunner.class)
//指定容器使用配置檔案
@ContextConfiguration("classpath:applicationContext.xml")
public class Deom {
    //將名為user的物件注入u變數中
    @Resource(name="user")
    private User u;
    @Test
    public void fun1() {
        System.out.println(u);
    }
}

9.aop

9.1aop思想

  • 橫向重複,縱向抽取

9.2Spring中的aop

  • Spring能夠為容器中管理的物件生成動態代理物件
  • 以前我們要使用動態代理,我們需要自己呼叫下面的方法生成物件Proxy.newProxyInstance(xx,xx,xx) 生成代理物件,Spring能夠幫我們生成代理物件
9.2.1Spring實現aop原理
  • 動態代理(優先)
    • 被代理物件必須要實現實現介面,才能產生代理物件。如果沒有介面不能使用動態代理技術。
  • cglib代理(沒有介面使用)
    • 第三方代理技術,cglib代理,可以對任何類實現代理,代理的原理是對目標物件進行繼承代理。如果目標物件被final修飾,該類無法被cglib代理。

9.3aop名詞解釋

  • JoinPoint(連線點):在目標物件中,所有可以增強的方法。
  • PointCut(切入點):目標物件,已經增強的方法。
  • Advice(通知/增強):增強的程式碼
  • Target(目標物件):被代理物件
  • WeAVing(織入):將通知應用到切入點的過程
  • Proxy(代理):將通知織入到目標物件之後,形成代理物件
  • Aspect(切面):切入點+通知

10.aop演示(XML配置)

  • 1.導包(4+2+2(spring_aop+spring_aspects)+2(com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar;com.springsource.org.aopalliance-1.0.0.jar))
  • 2.準備目標物件
public class UserServiceImpl implements UserService{
    @Override
    public void save() {
        System.out.println("儲存");
    }
    @Override
    public void delete() {
        System.out.println("刪除");
    }
    @Override
    public void update() {
        System.out.println("更新");
    }
    @Override
    public void find() {
        System.out.println("查詢");
    }
}
  • 3.準備通知
    • 前置通知 目標方法之前呼叫
    • 後置通知 (如果出現異常不會呼叫) 在目標方法執行之後
    • 環繞通知 在目標方法之前和之後都呼叫
    • 異常攔截通知 如果出現異常,就會呼叫
    • 後置通知 (無論是否出現異常都會呼叫) 在目標方法執行之後呼叫
public class MyAdvice {

    //前置通知,方法名是自己定義的
    public void before() {
        System.out.println("這是前置通知!");
    }
    //後置通知
    public void afterReturning() {
        System.out.println("這是後置通知(如果出現異常不會呼叫)");
    }
    //環繞通知
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("這是環繞通知之前的部分!");
        Object proceed = pjp.proceed();//呼叫目標方法
        System.out.println("這是環繞通知之後的部分!");
        return proceed;
    }
    //異常通知
    public void afterException() {
        System.out.println("異常出現了!");
    }
    //後置通知
    public void after() {
        System.out.println("這是後置通知(出現異常也會呼叫)");
    }
}
  • 4.配置進行織入,將通知織入目標物件中
    • 匯入aop約束
    • xml檔案中新增名稱空間
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">
<!-- 準備工作:匯入aop(約束)名稱空間 -->
<!-- 1.配置目標物件 -->
    <bean name="userService" class="com.sjtu.proxy.UserServiceImpl"></bean>
<!-- 2.配置通知物件 -->
    <bean name="myAdvice" class="com.sjtu.proxy.MyAdvice"></bean>   
<!-- 3.配置將通知織入切入點物件 -->
    <aop:config>
    <!-- 配置切入點 
        public void com.sjtu.proxy.UserServiceImpl.save()
         void com.sjtu.proxy.UserServiceImpl.save()
         * com.sjtu.proxy.UserServiceImpl.save()
         * com.sjtu.proxy.UserServiceImpl.*()

         * com.sjtu.proxy.*ServiceImpl.*(..)
         * com.sjtu.proxy..*ServiceImpl.*(..)
    -->
    <aop:pointcut expression="execution(* com.sjtu.proxy..*ServiceImpl.*(..))" id="pc"/>
        <aop:aspect ref="myAdvice">
            <!-- 指定為before方法作為前置通知 -->
            <aop:before method="before" pointcut-ref="pc"/>
            <!-- 後置 -->
            <aop:after method="after" pointcut-ref="pc"/> 
            <!-- 環繞通知 -->
            <aop:around method="around" pointcut-ref="pc"/>
            <!-- 異常攔截通知 -->
            <aop:after-throwing method="afterException" pointcut-ref="pc"/>
            <!-- 後置 -->
            <aop:after-returning method="afterReturning" pointcut-ref="pc"/>
        </aop:aspect>
    </aop:config>
</beans>
  • 5.程式碼測試
//建立容器
@RunWith(SpringJUnit4ClassRunner.class)
//指定容器使用配置檔案
@ContextConfiguration("classpath:com/sjtu/springaop/applicationContext.xml")
public class Deom {

    //將名為user的物件注入u變數中
    @Resource(name="userService")
    private UserService us;

    @Test
    public void fun1() {

        System.out.println(us);
        us.save();
    }
}

11.aop演示(註解)

  • 1.導包

  • 2.準備目標物件

  • 3.準備通知

  • 4.註解

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">
    <!-- 準備工作:匯入aop(約束)名稱空間 -->
    <!-- 1.配置目標物件 -->
        <bean name="userService" class="com.sjtu.proxy.UserServiceImpl"></bean>
    <!-- 2.配置通知物件 -->
        <bean name="myAdvice" class="com.sjtu.proxy.MyAdvice"></bean>   
    <!-- 3.註解配置 -->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    </beans>
    //表示是一個通知類
    @Aspect
    public class MyAdvice {
    
        @Pointcut("execution(* com.sjtu.proxy..*ServiceImpl.*(..))")
        public void pc() {}
    
        //前置通知
        //指定方法是前置通知,並制定切入點
        @Before("MyAdvice.pc()")
        public void before() {
            System.out.println("這是前置通知!");
        }
        //後置通知
        @AfterReturning("execution(* com.sjtu.proxy..*ServiceImpl.*(..))")
        public void afterReturning() {
            System.out.println("這是後置通知(如果出現異常不會呼叫)");
        }
        //環繞通知
        @Around("execution(* com.sjtu.proxy..*ServiceImpl.*(..))")
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
            System.out.println("這是環繞通知之前的部分!");
            Object proceed = pjp.proceed();
            System.out.println("這是環繞通知之後的部分!");
            return proceed;
        }
        //異常通知
        @AfterThrowing("execution(* com.sjtu.proxy..*ServiceImpl.*(..))")
        public void afterException() {
            System.out.println("異常出現了!");
        }
        //後置通知
        @After("execution(* com.sjtu.proxy..*ServiceImpl.*(..))")
        public void after() {
            System.out.println("這是後置通知(出現異常也會呼叫)");
        }
    }
    
  • 5.程式碼測試

12.Spring整合JDBC

12.1JDBCTemplate

  • spring中提供了一個可以操作資料庫的物件,物件封裝了jdbc技術。
  • 與DBUtils中QueryRunner非常相似
  • 與DBUtils中的QueryRunner非常相似
//C3P0的連線池設定
//1.準備連線池
ComboPooledDataSource dataSource=new ComboPooledDataSource();
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/spring");    
dataSource.setUser("root");
dataSource.setPassword("123456");
//2.建立JDBC模板物件
JdbcTemplate jTemplate=new JdbcTemplate();
jTemplate.setDataSource(dataSource);
//3.書寫sql,並執行
String sql="insert into t_user values(null,'babdd')";
jTemplate.update(sql);

12.2 JDBCTemplate連線資料庫

  • 1.導包:
    • 4(spring-beans+spring-context+spring-core+spring-expression)+2(spring-logging+spring-log4j)
    • 與Junit整合(spring-test+spring-aop)
    • JDBC驅動+C3P0連線池
    • spring-jdbc+spring-tx事務
  • 2.準備資料庫
  • 3.書寫Dao
    • uqdate
    • query(sql, rse, args);
    • queryForObject(sql, rse, args);
//使用JDBC模板實現增刪改查
public class UserDaoIml implements UserDao{

  //並且給jTemplate設定setter方法
    private JdbcTemplate jTemplate;
    @Override
    public void save(User u) {
        String sql="insert into t_user values(null,?)";
        jTemplate.update(sql, u.getName());
    }

    @Override
    public void delete(Integer id) {
        String sql="delete from t_user where id=?";
        jTemplate.update(sql, id);
    }

    @Override
    public void update(User u) {
        String sql="update t_user set name=? where id=?";
        jTemplate.update(sql, u.getName(),u.getId());
    }

    @Override
    public User getById(Integer id) {
        String sql="select * from t_user where id=?";
        return jTemplate.queryForObject(sql, new RowMapper<User>() {

            @Override
            public User mapRow(ResultSet rs, int arg1) throws SQLException {
                User user=new User();
                user.setId(rs.getInt("id"));
                user.setName(rs.getString("name"));
                return user;
            }}, id);
    }

    @Override
    public int getTotalCount() {
        String sql="select count(*) from t_user";
        Integer count = jTemplate.queryForObject(sql, Integer.class);
        return count;
    }

    @Override
    public List<User> getAll() {
        String sql="select * from t_user";
        return jTemplate.query(sql,new RowMapper<User>() {

            @Override
            public User mapRow(ResultSet rs, int arg1) throws SQLException {
                User user=new User();
                user.setId(rs.getInt("id"));
                user.setName(rs.getString("name"));
                return user;
            }});
    }

    public void setjTemplate(JdbcTemplate jTemplate) {
        this.jTemplate = jTemplate;
    }
}


  • 4.spring配置

    • 依賴關係
    • 注意三者的依賴關係,UserDaoImpl需要jdbcTemplate,jdbcTemplate需要datasource連線池,根據依賴關係,從下往上配置,顯示dataSource連線池,再是jdbcTemplate,最後是UserDao
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd ">
    <!-- 1.將連線池放入spring容器中 -->
    <bean name=