超詳細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 ">

<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

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>

<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= 
 
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    超詳細Spring入門講解
      
							
							
							




1.基本內容


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

  
 

    

    
    spring boot2.0一看就會的超詳細快速入門(一)
      maven構建方式一：pom.xml檔案中用parent標籤配置依賴傳遞 
開發工具：eclipse 
版本：Oxygen.3a Release(4.7.3a) 
開發環境 ：win10 
步聚1 ：新建maven工程 
 
  
勾選建立一個簡單工程，跳過骨架選擇，點選下一步，如圖： 
 
在配置 

  
 

    

    
    spring boot2.0一看就會的超詳細快速入門(三)-自定義父POM
      步聚一：新建maven工程，如下圖： 
 
把pom型別修改為pom，點選完成按鈕,表示是一個父工程： 
 
步聚二：配置pom.xml檔案，如下圖： 
 
步驟三：新建子maven工程，配置type為jar，並繼承springboot-parent工程，如下圖： 
 
 
 
步聚四：配置Springboo 

  
 

    

    
    spring boot2.0一看就會的超詳細快速入門(五)-開發人員工具devtools
      spring-boot-devtools模組可以包含在任何專案中，使應用程式開發更加方便 
maven repository： 
<dependencies> 
	<dependency>
		<groupId>org.springframework.boot</gr 

  
 

    

    
    spring boot2.0一看就會的超詳細快速入門(六)-整合Thymeleaf模板引擎
      1.理解Thymeleaf 
1.1 Thymeleaf是一個適用於Web和獨立環境的伺服器端java模板引擎，能夠處理HTML、XML、JavaScript、CSS甚至純檔案，常見類似的工具有JSP、Freemarker等 
1.2 Thymeleaf遵循的是一個自然模板的概念，主要目標是提供一種優雅且高度 

  
 

    

    
    spring boot2.0一看就會的超詳細快速入門(七)-訪問靜態資源
      常用靜態資源包含 ：js、css、圖片、音視訊等 
靜態資源路徑：指系統可以直接訪問的路徑，且路徑下的所有檔案都可以被直接讀取 
Springboot預設提供靜態資源目錄位置位於classpath下，目錄需要符合以下規則： 
    /static 
   /publi 

  
 

    

    
    【智慧演算法】粒子群演算法（Particle Swarm Optimization）超詳細解析+入門程式碼例項講解
      
喜歡的話可以掃碼關注我們的公眾號哦，更多精彩盡在微信公眾號【程式猿聲】

01 演算法起源
粒子群優化演算法(PSO)是一種進化計算技術(evolutionary computation)，1995 年由Eberhart 博士和kennedy 博士提出，源於對鳥群捕食的行為研究 。該演算法最初是受到飛鳥叢集 

  
 

    

    
    漲薪必備｜給你一份超詳細Spring Boot知識清單
      
 在過去兩三年的 Spring 生態圈，最讓人興奮的莫過於 Spring Boot 框架。或許從命名上就能看出這個框架的設計初衷：快速的啟動 Spring 應用。因而 Spring Boot 應用本質上就是一個基於 Spring 框架的應用，它是 Spring 對“約定優先於配置”理念的最佳實踐產物，它能夠 

  
 

    

    
    超詳細 Spring @RequestMapping 註解使用技巧
      
                Request Mapping 基礎用法
在 Spring MVC 應用程式中，RequestDispatcher (在 Front Controller 之下) 這個 servlet 負責將進入的 HTTP 請求路由到控制器的處理方法。
在對 Spring MVC 進行的配 

  
 

    

    
    給你一份超詳細 Spring Boot 知識清單
      
                

在過去兩三年的Spring生態圈，最讓人興奮的莫過於Spring Boot框架。或許從命名上就能看出這個框架的設計初衷：快速的啟動Spring應用。因而Spring Boot應用本質上就是一個基於Spring框架的應用，它是Spring對“約定優先於配置”理念的最佳實踐產 

  
 

    

    
    超強、超詳細Redis入門教程
      

1.redis是什麼
2.redis的作者何許人也
3.誰在使用redis
4.學會安裝redis
5.學會啟動redis
6.使用redis客戶端
7.redis資料結構 – 簡介
8.redis資料結構 – strings
9.redis資料結構 – lists
10.redis資料結構 – 集合
1 

  
 

    

    
    【Maven+SSM】超詳細Spring+SpringMVC+Redis整合
      
                前言：        文章背景，最近專案中做了一個上傳圖片的功能，由於是流式上傳，所以閘道器層沒有對使用者許可權做過濾。需要自己手動做使用者許可權校驗。但是，如果每次上傳圖片都進行資料庫查詢會造成資料庫壓力大。因此，看前人程式碼中，用到了redis快取讀取。學習記錄之。    

  
 

    

    
    超強、超詳細 Redis入門教程
      1.redis是什麼2.redis的作者何許人也3.誰在使用redis4.學會安裝redis5.學會啟動redis6.使用redis客戶端7.redis資料結構 – 簡介8.redis資料結構 – strings9.redis資料結構 – lists10.redis資料結構 – 集合11.redis資料結構  

  
 

    

    
    java框架：超詳細Spring知識點彙總
      1spring框架概述1.1什麼是springlSpring是一個開源框架，Spring是於2003 年興起的一個輕量級的Java 開發框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中闡述的部分理念和原型衍生而來。它是為了解決 

  
 

    

    
    阿裏P7給你一份超詳細 Spring Boot 知識清單
      tin   term   即將   F12   負責   docker   來替   說過   one   在過去兩三年的Spring生態圈，最讓人興奮的莫過於Spring Boot框架。或許從命名上就能看出這個框架的設計初衷：快速的啟動Spring應用。因而Spring Boot應用本質上就是一個基於Spr 

  
 

    

    
    超詳細Spring Boot面試問題集錦，死角一個不留！
      
                                        
                                                全文共2564字，預計學習時長5分鐘 
本文將討論Spring Boot中最常見的10個面試問題。在當今就業市場中，這些問題出現的 

  
 

    

    
    超詳細的Spring Boot入門筆記
      
							
							
							1.   Spring Boot 入門 
Spring Boot是Spring社群較新的一個專案。該專案的目的是幫助開發者更容易的建立基於Spring的應用程式和服務，讓更多人的人更快的對Spring進行入門體驗，讓Java開發也能夠實現Ruby on Rail 

  
 

    

    
    字首和 線段樹 樹狀陣列講解（超詳細入門）
      
                部落格目錄

Part one、字首和

     引入問題：現輸入長度為n的數列co，再輸入q個詢問，每個詢問都給出兩個整數l，r。對於每個詢問都要求給出對於數列co在區間[l,r]上的和（假設下標從0開始）。

     1. 最直觀的方法，就是直接暴力求解，每給出一對l 

  
 

    

    
    Android自定義相機超詳細講解
      了解   catch   實現   4.4   required   form   需要   eset   自己   Android自定義相機超詳細講解

轉載請標明出處： http://blog.csdn.net/vinicolor/article/details/49642861；

由於網上關於Andr 

  
 

    

    
    java程式設計師菜鳥進階（十三）linux基礎入門（一）vmvare下安裝linux RedHat圖解（超詳細篇）
       
 
 
  對於linux，我從大二就想學習一下，但一直苦於無從下手，所以一直拖到現在，鑑於筆者瞭解很多人在linux入門的困難在何處，所以我認為本套入門基礎文章還是挺適合想學習linux的朋友，本系列文章大約十篇文章左右，近期會不斷更新下來，沒有linux基礎但又想學習linux的朋友可以關注一下本系列