Resource resource = new ClassPathResource("applicationContext.xml");
BeanFactory factory = new XmlBeanFactory(resource);  

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation)

ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation);

<!--指定Spring配置文件的位置，有多個配置文件時，以逗號分隔-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <!--spring將加載spring目錄下的applicationContext.xml文件-->
    <param-value>
        classpath:spring/applicationContext.xml
    </param-value>
</context-param>
<!--指定以ContextLoaderListener方式啟動Spring容器-->
<listener>
    <listener-class>
        org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:schemaLocation="http://www.springframework.org/schema/beans      http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="user" class="com.wyl.pojo.User">
        <property name="name" value="王延領"/>
    </bean>
</beans>

public class User { 
    private String name; 
    public User() {
        System.out.println("user無參構造方法");
    } 
    public void setName(String name) {
        this.name = name;
    } 
    public void show(){
        System.out.println("name="+ name );
    }
}

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    //在執(zhí)行getBean的時候, user已經(jīng)創(chuàng)建好了 , 通過無參構造
    User user = (User) context.getBean("user");
    //調用對象的方法 .
    user.show();
}

<!-- 1. 默認構造函數(shù)，如果類中沒有默認構造函數(shù)則無法創(chuàng)建對象;bean標簽中只有id和class就默認使用構造函數(shù)創(chuàng)建對象 -->
<bean id="userService" class="com.wyl.pojo.User"/>

<!-- 第一種根據(jù)index參數(shù)下標設置 -->
<bean id="userService" class="com.wyl.pojo.User">
    <!-- index指構造方法 , 下標從0開始 -->
    <constructor-arg index="0" value="wyl"/>
</bean>
 
<!-- 第二種根據(jù)參數(shù)名字設置 -->
<bean id="userService" class="com.wyl.pojo.User">
    <!-- name指參數(shù)名 -->
    <constructor-arg name="name" value="wyl"/>
</bean>
<!-- 第三種根據(jù)參數(shù)類型設置 -->
<bean id="userService" class="com.wyl.pojo.User">
    <constructor-arg type="java.lang.String" value="wyl"/>
</bean>

<!-- 2. 使用工廠中的方法創(chuàng)建對象;工廠中有一個方法可以創(chuàng)建對象，先創(chuàng)建工廠對象，通過factory-bean指向工廠，使用factory-method方法獲取對象 -->
<bean id="beanFactory" class="org.factory.BeanFactory"/>
<bean id="userService" factory-bean="beanFactory" factory-method="getUserService"/>

<!-- 3. 使用靜態(tài)工廠中的靜態(tài)方法創(chuàng)建對象 -->
<bean id="userService" class="org.factory.StaticBeanFactory" factory-method="getUserService"/>

<!--  別名 : 如果添加了別名，我們也可以使用別名獲取到這個對象 -->
<alias name="User" alias="u1"></alias>

<!--
  bean標簽常用屬性：

id屬性：起名稱，id屬性值名稱任意命名，不能包含特殊符號
class屬性：創(chuàng)建對象所在類的全路徑
name屬性：功能和id屬性一樣的，但是在name屬性值里面可以包含特殊符號
scope屬性
singleton：默認值，單例
prototype：多例
request：創(chuàng)建對象把對象放到request域里面
session：創(chuàng)建對象把對象放到session域里面
globalSession：創(chuàng)建對象把對象放到globalSession里面
  -->
<bean id="UserT" class="com.wyl.pojo.User" scope="singleton" name="u2 u21,u22;u23">
    <property name="name" value="123"/>
</bean>

<bean id="..." class="..." scope="singleton"/>

public class UserBean {
	private String name;  
    
    public UserBean(){  
        System.out.println("UserBean()構造函數(shù)");  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        System.out.println("setName()");  
        this.name = name;  
    }  
    public void init(){  
        System.out.println("this is init of UserBean");  
    }  
      
    public void destory(){  
        System.out.println("this is destory of UserBean " + this);  
    }  
}

<bean id="user_singleton" class="com.wyl.userBean" scope="singleton" 
			init-method="init" destroy-method="destory" lazy-init="true"/>

<beans default-lazy-init="true">

public class LifeTest {
	@Test 
	public void test() {
		AbstractApplicationContext container = 
		new ClassPathXmlApplicationContext("user.xml");
		UserBean user = (UserBean)container.getBean("user_singleton");
		System.out.println(user);
		container.close();
	}
}

public class UserTest {
	@Test 
	public void test() {
		AbstractApplicationContext container = new ClassPathXmlApplicationContext("User.xml");
		UserBean User1 = (UserBean)container.getBean("User_singleton");
		System.out.println(User1);
		
		UserBean User2 = (UserBean)container.getBean("User_prototype");
		System.out.println(User2);
		container.close();
	}
}

private String name;
private Integer age;
private Date birthday;
// 構造函數(shù)
public UserServiceImpl(String name, Integer age, Date birthday) {
this.name = name;
this.age = age;
this.birthday = birthday;
}

<!-- name：按字段名稱輔助；index：字段索引，給第幾個字段賦值；type：指定注入值的類型，該類型也是構造函數(shù)中某個或某些字段的類型； -->
<!-- value:要注入的值，基本類型和String；ref：注入其他類型數(shù)據(jù)，指向外部bean對象;這個外部bean需要存在于Spring容器 -->
<bean id="userService" class="org.service.impl.UserServiceImpl">
    <constructor-arg name="name" value="張三"/>
    <constructor-arg name="age" value="12"/>
    <constructor-arg name="birthday" ref="date"/>
</bean>
<!-- 創(chuàng)建日期對象 -->
<bean id="date" class="java.util.Date"/>

private String name;
private Integer age;
private Date birthday;
public void setName(String name) {
    this.name = name;
}

public void setAge(Integer age) {
    this.age = age;
}

public void setBirthday(Date birthday) {
    this.birthday = birthday;
}

<bean id="userService2" class="org.service.impl.UserServiceImpl2">
    <property name="name" value="李四"/>
    <property name="age" value="12"/>
    <property name="birthday" ref="date"/>
</bean>
<!-- 創(chuàng)建日期對象 -->
<bean id="date" class="java.util.Date"/>

<!-- 注入對象類型屬性 -->
<!-- 1 配置service和dao對象 -->
<bean id="userDao" class="cn.ioc.UserDao"></bean>
<bean id="userService" class="cn.ioc.UserService">
    <!-- 注入dao對象-->
    <property name="userDao" ref="userDao"></property>
</bean>

<!-- 注入復雜類型屬性值 -->
  <bean id="person" class="cn.property.Person">
    <!-- 數(shù)組 -->
    <property name="arrs">
       <list>
         <value>小王</value>
         <value>小馬</value>
         <value>小宋</value>
       </list>
    </property>
    
    <!-- list -->
    <property name="list">
       <list>
         <value>小奧</value>
         <value>小金</value>
         <value>小普</value>
       </list>      
    </property>

    <!-- map -->
    <property name="map">
       <map>
         <entry key="aa" value="lucy"></entry>
         <entry key="bb" value="mary"></entry>
         <entry key="cc" value="tom"></entry>
       </map>
    </property>

    <!-- properties -->
    <property name="properties">
       <props>
         <prop key="driverclass">com.mysql.jdbc.Driver</prop>
         <prop key="username">root</prop>
       </props>
    </property>
  </bean>
<!--set-->
<property name="set">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>WOW</value>
            </set>
</property>
<!--null-->
<property name="marne">
            <null/>
</property>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

<!-- p命名空間注入，可以直接注入屬性的值：property -->
<bean id="User"  class="com.wyl.pojo.User" p:name ="老秦" p:age ="18"/>

<!-- c命名空間注入，通過構造器注入：construct-args -->
<bean id="User2" class="com.wyl.pojo.User" c:age="18" c:name="老李"/>

<!--
byName：會自動在容器上下文中查找，和自己對象set方法后面的值對應的beanid！
-->
<bean id="people" class="com.wyl.pojo.People" autowire="byName">
    <property name="name" value="wangyanling"/>
</bean>

<bean id="cat" class="com.wyl.pojo.Cat"/>
    <bean id="dog" class="com.wyl.pojo.Dog"/>
    <!--
    byName：會自動在容器上下文中查找，和自己對象set方法后面的值對應的beanid！
    byType：會自動在容器上下文中查找，和自己對象屬性類型相同的bean！
    -->
    <bean id="people" class="com.wyl.pojo.People" autowire="byType">
        <property name="name" value="WANGAYNLING"/>
    </bean>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

 @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;

@Nullable     // 字段標記了這個注解，說明這個字段可以為null

public class People {
    private String name;
    @Autowired
    @Qualifier("cat")
    private Cat cat;
    @Autowired
    @Qualifier("dog")
    private Dog dog;
}

public class People {
    private String name;
    @Resource(name = "cat")
    private Cat cat;
    @Resource(name = "dog")
    private Dog dog;

@PostConstruct
public void init() {
    System.out.println("初始化注解");
}
@PreDestroy
public void destroy() {
    System.out.println("銷毀注解");
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ApplicationConfig.class) 純注解
// @ContextConfiguration(locations = "classpath:ApplicationContext.xml") xml配置文件
public class SpringTest {

    @Autowired
    private AccountServiceImpl accountService;

    @Test
    public void findAll(){
        List<Account> accountList = accountService.findAll();
        for (Account account : accountList) {
            System.out.println(account);
        }
    }
   
}

public class User {
    private Integer id;
    private String name;
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans        
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.wyl.bean.User" >
        <property name="id" value="1"></property>
        <property name="name" value="wyl"></property>
    </bean>
</beans>

@test
public void UserTest{
ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("Bean.xml");
        User userInfo=(User)context.getBean("user");
        System.out.println(userInfo);
}

@Configuration
public class MyTestConfig {
    //bean的id默認為方法名
    @Bean
    public User user(){
        User user =new User();
        user.setName("王延領");
        user.setId(2);
        return user;
    }
}
@test
public void UserTest{
    AnnotationConfigApplicationContext context=new 							AnnotationConfigApplicationContext(MyTestConfig.class);
        User userInfo=(User)context.getBean("user");
        System.out.println(userInfo.toString());
        }

public interface Rent {
    public void rent();
}

public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房東出租房子！");
    }
}

public class Proxy {
    private Host host;
    public Proxy(){
 
    }
    public Proxy(Host host){
        this.host=host;
    }
    public void rent(){
        seeHouse();
 
        host.rent();
        hetong();
        fare();
    }
    public void seeHouse(){
        System.out.println("中介帶你看房");
    }
    public void fare(){
        System.out.println("收中介費!");
    }
    public void hetong(){
        System.out.println("簽租領合同");
    } 
 
}

public class Client {
    public static void main(String[] args) {
        Host host=new Host();
        //host.rent();
        Proxy proxy=new Proxy(host);
        proxy.rent();
    }
}

//抽象角色：租房
public interface Rent {
    public void rent();
}
//真實角色: 房東，房東要出租房子
public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}
//代理:中介
public class ProxyInvocationHandler implements InvocationHandler {
    private Rent rent;
 
    public void setRent(Rent rent) {
        this.rent = rent;
    }
 
    //生成代理類，重點是第二個參數(shù)，獲取要代理的抽象角色！之前都是一個角色，現(xiàn)在可以代理一類角色
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(),this);
    }
 
    // proxy : 代理類 method : 代理類的調用處理程序的方法對象.
    // 處理代理實例上的方法調用并返回結果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //核心：本質利用反射實現(xiàn)！
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }
 
    //看房
    public void seeHouse(){
        System.out.println("帶房客看房");
    }
    //收中介費
    public void fare(){
        System.out.println("收中介費");
    }
}
//租客
public class Client {
 
    public static void main(String[] args) {
        //真實角色
        Host host = new Host();
        //代理實例的調用處理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host); //將真實角色放置進去！
        Rent proxy = (Rent)pih.getProxy(); //動態(tài)生成對應的代理類！
        proxy.rent();
    }
 
}

// 被代理的對象
Account account = new Account();
Account o = (Account) Enhancer.create(account.getClass(), new MethodInterceptor() {
    /**
    * 被代理對象的方法執(zhí)行前會執(zhí)行
    * @param obj 被代理的對象
    * @param method 方法
    * @param objects 參數(shù)
    * @param methodProxy 當前執(zhí)行方法的代理的對象
    * @return 和被代理對象的方法相同的返回值
    * @throws Throwable 異常
    */
    @Override
    public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("增強前...");
        Object invoke = method.invoke(account, objects);
        System.out.println("增強后...");
        return invoke;
    }
});
o.findAll();

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

//接口與業(yè)務
public interface UserService {
 
    public void add();
 
    public void delete();
 
    public void update();
 
    public void search();
 
} 
public class UserServiceImpl implements UserService{
 
    @Override
    public void add() {
        System.out.println("增加用戶");
    }
 
    @Override
    public void delete() {
        System.out.println("刪除用戶");
    }
 
    @Override
    public void update() {
        System.out.println("更新用戶");
    }
 
    @Override
    public void search() {
        System.out.println("查詢用戶");
    }
}

//增強
public class AfterLog implements AfterReturningAdvice {
    //returnValue 返回值
    //method被調用的方法
    //args 被調用的方法的對象的參數(shù)
    //target 被調用的目標對象
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("執(zhí)行了" + target.getClass().getName()
        +"的"+method.getName()+"方法,"
        +"返回值："+returnValue);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
 
    <!--注冊bean-->
    <bean id="userService" class="com.wyl.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
 
    <!--aop的配置-->
    <aop:config>
        <!--切入點  expression:表達式匹配要執(zhí)行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.wyl.service.UserServiceImpl.*(..))"/>
        <!--執(zhí)行環(huán)繞; advice-ref執(zhí)行方法 . pointcut-ref切入點-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
 
</beans>

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.search();
    }
}

//切入類
public class DiyPointcut {
 
    public void before(){
        System.out.println("---------方法執(zhí)行前---------");
    }
    public void after(){
        System.out.println("---------方法執(zhí)行后---------");
    }
    
}

<!--第二種方式自定義實現(xiàn)-->
<!--注冊bean-->
<bean id="diy" class="com.wyl.config.DiyPointcut"/
<!--aop的配置-->
<aop:config>
    <!--第二種方式：使用AOP的標簽實現(xiàn)-->
    <aop:aspect ref="diy">
        <aop:pointcut id="diyPonitcut" expression="execution(* com.wyl.service.UserServiceImpl.*(..))"/>
        <aop:before pointcut-ref="diyPonitcut" method="before"/>
        <aop:after pointcut-ref="diyPonitcut" method="after"/>
    </aop:aspect>
</aop:config>

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

//注解實現(xiàn)的增強類
package com.wyl.config;
 
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
 
@Aspect
public class AnnotationPointcut {
    @Before("execution(* com.wyl.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("---------方法執(zhí)行前---------");
    }
 
    @After("execution(* com.wyl.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("---------方法執(zhí)行后---------");
    }
 
    @Around("execution(* com.wyl.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("環(huán)繞前");
        System.out.println("簽名:"+jp.getSignature());
        //執(zhí)行目標方法proceed
        Object proceed = jp.proceed();
        System.out.println("環(huán)繞后");
        System.out.println(proceed);
    }
}

// Spring自帶的數(shù)據(jù)源
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/spring?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai");
dataSource.setUsername("root");
dataSource.setPassword("root");
JdbcTemplate template = new JdbcTemplate(dataSource);

List<Account> accountList = template.query("select * from account", new BeanPropertyRowMapper<>(Account.class));
for (Account account : accountList) {
    System.out.println(account);
}

@Autowired
private JdbcTemplate jdbcTemplate;

// 添加
@Test
public void insert(){
    String sql = "insert into account(name, money) VALUES (?,?)";
    Account account1 = new Account();
    account1.setName("迪迦");
    account1.setMoney(10000F);
    jdbcTemplate.update(sql, account1.getName(), account1.getMoney());
    find();
}

// 刪除
@Test
public void delete(){
    String sql = "delete from account where id = ?";
    jdbcTemplate.update(sql, 6);
    find();
}

// 更新
@Test
public void update(){
    List<Account> accounts = jdbcTemplate.query("select * from account where id = ?", new BeanPropertyRowMapper<>(Account.class), 1);
    Account account = accounts.get(0);
    account.setName("泰羅");
    String sql = "update account set name = ? where id = ?";
    jdbcTemplate.update(sql, account.getName(),account.getId());
    find();
}

// 查詢所有
@Test
public void find(){
    List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<>(Account.class));
    for (Account account : accountList) {
        System.out.println(account);
    }
}

// 查詢一個bean
@Override
public Account findByName(String name) {
    String sql = "select * from account where name = ?";
    return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Account.class), name);
}

// 查詢一個Object
@Test
public void findOne(){
    String sql = "select count(id) from account";
    Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
    System.out.println(integer);
}

1、配置事務管理器
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/></bean>

2、配置通知
<!-- 配置事務的通知/增強 -->
<tx:advice id="interceptor">
    <!-- 配置事務的屬性 -->
    <!-- isolation:事務隔離級別，默認使用數(shù)據(jù)庫的隔離級別
         no-rollback-for：指定一個異常，除了該異常都回滾。
         propagation:事務傳播行為，默認是required一定有事務，增刪改設置required，查詢設置supports
         read-only：是否只讀。只有查詢才能設置true。默認是false支持讀寫。
         rollback-for：指定一個異常，出現(xiàn)該異常就回滾，其他異常不回滾。
         timeout：事務超時時間，默認-1，永不超時。指定了以秒為單位。 -->
    <tx:attributes>
        <!-- 指定在哪種規(guī)則的方法上添加事務 -->
        <tx:method name="transfer*"/>
    </tx:attributes>
</tx:advice>

3、事務管理器和切入點表達式關聯(lián)起來
<aop:config>
    <!-- service包下所有類的所有方法都添加事務 -->
    <aop:pointcut id="commonPointcut" expression="execution(* com.sample.service.*.*(..))"/>
    <!-- 將事務管理器和切入點表達式關聯(lián)起來 -->
    <aop:advisor advice-ref="interceptor" pointcut-ref="commonPointcut"/>
</aop:config>

1、配置事務管理器
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/></bean>

2、開啟對事務注解的支持
<!-- 開啟對事務注解的支持 -->
<tx:annotation-driven/>

3、在要添加事物的類上添加注解：@Transactional

@Configuration
@ComponentScan("com.sample")
// 相當于<tx:annotation-driven/>
@EnableTransactionManagement
@PropertySource("classpath:db.properties")
public class AppConfig {

    @Value("${db.driver}")
    private String driver;
    @Value("${db.url}")
    private String url;
    @Value("${db.username}")
    private String username;
    @Value("${db.password}")
    private String password;

    @Bean
    public DruidDataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(){
        return new JdbcTemplate(dataSource());
    }

    @Bean
    public DataSourceTransactionManager transactionManager(){
        return new DataSourceTransactionManager(dataSource());
    }

}

==========
在類上添加@Transactional注解即可