Java - 框架之 Spring

一. IOC 和 DI

IOC : 控制反转，将对象的创建权反转给了 Spring。
DI : 依赖注入，前提是必须要有 IOC 的环境，Spring 管理这个类的时候将类的依赖的属性注入(设置)进来。

二. 工厂类

//  1. 加载类路径

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

UserDao userDao = (UserDao) applicationContext.getBean("userDao");

userDao.save();

// 2. 加载磁盘中的 文件路径

ApplicationContext applicationContext = new FileSystemXmlApplicationContext("C:/Users/Administrator/Desktop/applicationContext.xml");

UserDao userDao = (UserDao) applicationContext.getBean("userDao");

userDao.save();

三. Bean 的作用范围配置 (xml 文件中)

1. scope : Bean 的作用范围。
！   - singleton     : 默认，Spring 会采用单例模式创建这个对象。
！   - prototype     : 多例模式。(Struts2 和 Spring 整合时会用到)
   - request       : 应用在 Web 项目中，Spring 创建这个类以后，将这个类存入到 request 范围中。
   - session       : 应用在 Web 项目中，Spring 创建这个类以后，将这个类存入到 session 范围中。
   - globalsession : 应用在 Web 项目中，必须在 porlet 环境下使用，如果没有这个环境，相对于 session。

四. Spring 的属性注入方式（xml）

1. 构造方法
// 构造方法 (需要提供构造器)

<!--  1. 构造方法  -->

<bean id="shop" class="com.q.spring.demo2.ShopDao">

    <constructor-arg name="name" value="apple" />

    <constructor-arg name="price" value="100" />

</bean>

@Test

public void demo1(){

    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

    ShopDao shopDao = (ShopDao) applicationContext.getBean("shop");

    System.out.println(shopDao);

}

2. set 方式的属性注入

<!--  2. set 方法  -->

<bean id="shop2" class="com.q.spring.demo2.ShopDao2">

    <property name="name" value="pear" />

    <property name="price" value="22" />

</bean>

<!--  2. set 方法 (p名称空间属性注入) -->

<bean id="shop2" class="com.q.spring.demo2.ShopDao2" p:name="q" p:price="2222"></bean>

<!--  2. set 方法 (SpEL 属性注入) -->

<bean id="shop2" class="com.q.spring.demo2.ShopDao2">

    <property name="name" value="#{'q1'}"></property>

    <property name="price" value="#{111}"></property>

</bean>

// set 方式的属性注入(需要提供 set 方法)

@Test

public void demo2(){

    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

    ShopDao2 shopDao = (ShopDao2) applicationContext.getBean("shop2");

    System.out.println(shopDao);

}

3. set 方法注入对象类型 (属性中依赖类)

<!--  3. set 方法注入对象类型的属性  -->

<bean id="person" class="com.q.spring.demo2.Person">

    <property name="name" value="q" />

    <property name="shopDao2" ref="shop2" />

</bean>

<!--  3. set 方法注入对象类型的属性 (p名称空间属性注入) -->

<bean id="person" class="com.q.spring.demo2.Person" p:name="q1" p:shopDao2-ref="shop2"></bean>

<!--  3. set 方法注入对象类型的属性 (SpEL 属性注入) -->

<bean id="person" class="com.q.spring.demo2.Person">

    <property name="name" value="#{'q1'}"></property>

    <property name="shopDao2" value="#{shop2}"></property>

</bean>

// set 方法注入对象类型(需要提供 set 方法)

@Test

public void demo3(){

    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

    Person person = (Person) applicationContext.getBean("person");

    System.out.println(person);

}

4. p名称空间属性注入

<bean id="person" class="com.q.spring.demo2.Person" p:name="q1" p:shopDao2-ref="shop2"></bean>

5. SpEL 属性注入 (Spring 3.0 之后)

<bean id="shop2" class="com.q.spring.demo2.ShopDao2">

    <property name="name" value="#{'q1'}"></property>

    <property name="price" value="#{111}"></property>

</bean>

6. 集合类型的注入 ( arrs list set map )

private String[] arrs;

private List<String> list;

private Set<String> set;

private Map<String, String> map;

<bean id="typealls" class="com.q.spring.demo2.typeAlls">

    <!--  数组类型  -->

    <property name="arrs">

        <list>

            <value>a</value>

            <value>b</value>

            <value>c</value>

        </list>

    </property>

    <!--  list集合  -->

    <property name="list">

        <list>

            <value>a1</value>

            <value>b1</value>

            <value>c1</value>

        </list>

    </property>

    <!--  set集合  -->

    <property name="set">

        <set>

            <value>a1</value>

            <value>b1</value>

            <value>c1</value>

        </set>

    </property>

    <!--  map 集合  -->

    <property name="map">

        <map>

            <entry key="b2" value="b2" />

            <entry key="b2" value="b2" />

            <entry key="b2" value="b2" />

        </map>

    </property>

</bean>

五. 分模块开发的配置

1. 直接在一个xml文件中导入

<import resource="applicationContext.xml" />

2. 在创建 ClassPathXmlApplicationContext 时可传多个参数路径

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml1"，"applicationContext.xml2");

六. Spring 的 IOC 注解开发

1. 引入约束: 使用注解开发引入 Context 约束

<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

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

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

</beans>

2. 开启 Spring 的组件扫描

<!--  配置组件扫描(哪些包下的类使用IOC注解)  -->

<context:component-scan base-package="包路径"></context:component-scan>

3. 在类上添加注解

- @Component : 组件
- 装饰一个类，将这个类交给 Spring 管理。

- 这个注解有三个衍生注解:       - @Controller : web 层
       - @Service       : service 层
       - @Repository : dao 层

import org.springframework.stereotype.Component;

// value 可省略: @Component("shopDao")

@Component(value = "userDao")  // 相当于在 <bean id="userDao" class="com.q.spring.demo2.userDemo2" />

public class userDemo2 implements UserDao {

    public void save(){

    }

}

4. 注解方式设置属性值

注解方式：使用注解方式，可以没有 set 方法。

- 属性如果有 set 方法，需要将属性注入的注解加到 set 方法上。

// 如：

@Value("添加注解")

public void setName(String name){

    this.name = name;

}

- 属性如果没有 set 方法，需要将属性注入的注解添加到属性上。

// 如：

@Value("添加注解")

private String name;

5. 属性注入的注解

# 普通属性：
   @Value    : 设置普通属性的值
# 对象类型属性：
   @Autowired : 设置对象类型的属性值。但是按照类型完成属性注入(按照类名的一致)。
       - 可以通过 @Qualifier 和 @Autowired 配合使用来修改为按照名称属性注入。

   @Resource : 完成对象类型的属性注入，按照名称完成属性注入。 (常用)。

6. Bean 的其他注解

# 生命周期相关注解：
@PostConstruct : 初始化方法
@PreDestroy : 销毁方法

# Bean 作用范围的注解：
   @scope   : 作用范围
   参数：
       - singleton : 默认单例
       - prototype : 多例

七. Spring 的 AOP 的 XML 开发

1. applocationContext.xml 文件配置

<?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 id="productDao" class="com.q.spring.demo1.ProductDaoImpl" />

    <!--  将切面类交给 Spring 管理  -->

    <bean id="myAspect" class="com.q.spring.demo1.MyAspectXml" />

    <aop:config>

        <!--  通过AOP的配置完成对目标类产生代理  -->

        <aop:pointcut expression="execution(* com.q.spring.demo1.ProductDaoImpl.save(..))" id="pointcut1" />

        <aop:pointcut expression="execution(* com.q.spring.demo1.ProductDaoImpl.delete(..))" id="pointcut2" />

        <aop:pointcut expression="execution(* com.q.spring.demo1.ProductDaoImpl.update(..))" id="pointcut3" />

        <aop:pointcut expression="execution(* com.q.spring.demo1.ProductDaoImpl.find(..))" id="pointcut4" />

        <!--  配置切面  -->

        <aop:aspect ref="myAspect">

            <!--  前置通知：获得切入点信息  -->

            <aop:before method="checkPri" pointcut-ref="pointcut1" />

            <!--  后置通知  -->

            <aop:after-returning method="writeLog" pointcut-ref="pointcut2" returning="result" />

            <!--  环绕通知  -->

            <aop:around method="around" pointcut-ref="pointcut3" />

            <!--  异常抛出通知  -->

            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="ex" />

            <!--  最终通知  -->

            <aop:after method="after" pointcut-ref="pointcut4" />

        </aop:aspect>

    </aop:config>

</beans>

2. ProductDao.java 接口文件

package com.q.spring.demo1;

public interface ProductDao {

    public void save();

    public void update();

    public String delete();

    public void find();

}

3. ProductDaoImpl.java DAO文件

package com.q.spring.demo1;

public class ProductDaoImpl implements ProductDao {

    @Override

    public void save() {

        System.out.println("save");

    }

    @Override

    public void update() {

        System.out.println("update");

    }

    @Override

    public String delete() {

        System.out.println("delete");

        return "Delete!!!";

    }

    @Override

    public void find() {

        System.out.println("find");

//        int i = 1/0;

    }

}

4. MyAspectXML.java

package com.q.spring.demo1;

// 切面类

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspectXml {

    // 前置通知

    public void checkPri(JoinPoint joinpoint){

        System.out.println("权限校验 "+ joinpoint);

    }

    // 后置通知

    public void writeLog(Object result){

        System.out.println("日志记录 "+ result);

    }

    // 环绕通知 : 性能监控

    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{

        System.out.println("环绕前通知...");

        Object obj = joinPoint.proceed();

        System.out.println("环绕后通知...");

        return obj;

    }

    // 异常抛出通知

    public void afterThrowing(Throwable ex){

        System.out.println("异常抛出通知..."+ ex.getMessage());

    }

    // 最终通知：类似于 finally

    public void after(){

        System.out.println("最终通知...");

    }

}

5. 测试文件

package com.q.spring.demo1;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class SpringDemo1 {

    @Resource(name="productDao")

    private ProductDao productDao;

    @Test

    public void demo1(){

        productDao.save();

        productDao.update();

        productDao.delete();

        productDao.find();

    }

}

八. Srping 的 AOP 注解

1. applocationContext.xml 文件

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

       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/context

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

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd">

        <!--  在配置文件中开启注解的AOP开发  -->

        <aop:aspectj-autoproxy />

        <!--  配置目标类  -->

        <bean id="orderDao" class="com.q.spring.demo1.OrderDao" />

        <!--  配置切面类  -->

        <bean id="myAspect" class="com.q.spring.demo1.MyAspectAnno" />

</beans>

2. OrderDao.java 文件

package com.q.spring.demo1;

public class OrderDao {

    public void save(){

        System.out.println("save...");

    }

    public void update(){

        System.out.println("update...");

    }

    public String delete(){

        System.out.println("delete...");

        return "Delete!!!";

    }

    public void find(){

        System.out.println("find...");

//        int i = 1/0;

    }

}

3. MyAspectAnno.java 文件

package com.q.spring.demo1;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.*;

@Aspect

public class MyAspectAnno {

    // 前置通知

    // execution(* com.q.spring.demo1.OrderDao.save(..))

    @Before(value = "MyAspectAnno.pointcut1()")

    public void befor(){

        System.out.println("前置增强");

    }

    // 后置通知

    @AfterReturning(value = "MyAspectAnno.pointcut3()", returning = "result")

    public void afterReturning(Object result){

        System.out.println("后置增强 "+ result);

    }

    // 环绕通知

    @Around(value = "MyAspectAnno.pointcut2()")

    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{

        System.out.println("环绕前增强");

        Object obj = joinPoint.proceed();

        System.out.println("环绕后增强");

        return obj;

    }

    // 异常抛出通知

    @AfterThrowing(value = "MyAspectAnno.pointcut4()", throwing = "e")

    public void afterThrowing(Throwable e){

        System.out.println("异常抛出增强: "+e);

    }

    // 最终通知

    @After(value = "MyAspectAnno.pointcut4()")

    public void afterThrowing(){

        System.out.println("最终增强");

    }

    // 切入点注解

    @Pointcut(value = "execution(* com.q.spring.demo1.OrderDao.save(..))")

    private void pointcut1(){}

    @Pointcut(value = "execution(* com.q.spring.demo1.OrderDao.update(..))")

    private void pointcut2(){}

    @Pointcut(value = "execution(* com.q.spring.demo1.OrderDao.delete(..))")

    private void pointcut3(){}

    @Pointcut(value = "execution(* com.q.spring.demo1.OrderDao.find(..))")

    private void pointcut4(){}

}

4. SpringDemo1.java 文件

package com.q.spring.demo1;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class SpringDemo1 {

    @Resource(name = "orderDao")

    private OrderDao orderDao;

    @Test

    public void demo1(){

        orderDao.save();

        orderDao.update();

        orderDao.delete();

        orderDao.find();

    }

}

九. Spring 的 JDBC 模板
Spring 是一站式框架，有持久层解决方案

1. DBCP 连接池
# 文档..

2. C3P0 连接池

# applicationContext.xml 配置

<?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"

       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/context

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

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd">

        <!--  配置C3P0连接池  -->

<!--        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">-->

<!--                <property name="driverClass" value="com.mysql.jdbc.Driver" />-->

<!--                <property name="jdbcUrl" value="jdbc:mysql:///spring_jdbc" />-->

<!--                <property name="user" value="root" />-->

<!--                <property name="password" value="chaoqi" />-->

<!--        </bean>-->

        <!--  引入属性文件  -->

        <context:property-placeholder location="classpath:jdbc.properties" />

        <!--  配置C3P0连接池  -->

        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

                <property name="driverClass" value="${jdbc.driverClass}" />

                <property name="jdbcUrl" value="${jdbc.url}" />

                <property name="user" value="${jdbc.username}" />

                <property name="password" value="${jdbc.password}" />

        </bean>

        <!--  配置 Spring 的JDBC的模板  -->

        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

                <property name="dataSource" ref="dataSource" />

        </bean>

</beans>

# 增删改查操作

package com.q.jdbc.demo1;

import com.q.jdbc.domain.Account;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.core.RowMapper;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class JdbcDemo2 {

    @Resource(name = "jdbcTemplate")

    private JdbcTemplate jdbcTemplate;

    // 增

    @Test

    public void demo1(){

        jdbcTemplate.update("insert into account values(null,?,?)","q4",152d);

    }

    // 改

    @Test

    public void demo2(){

        jdbcTemplate.update("update account set name=?, money = ? where id=? ","q1test",11d,2 );

    }

    // 删

    @Test

    public void demo3(){

        jdbcTemplate.update("delete from account where id=? ",2);

    }

    // 查

    @Test

    public void demo4(){

        String name = jdbcTemplate.queryForObject("select name from account where id=?",String.class,3);

        System.out.println(name);

    }

    // 统计查询

    @Test

    public void demo5(){

        Long count = jdbcTemplate.queryForObject("select count(*) from account",Long.class);

        System.out.println(count);

    }

    // 封装到一个对象中

    @Test

    public void demo6(){

        Account account = jdbcTemplate.queryForObject("select * from account where id = ?", new MyRowMapper(), 3);

        System.out.println(account);

    }

    // 查询多条记录

    @Test

    public void demo7(){

        List<Account> list = jdbcTemplate.query("select * from account", new MyRowMapper());

        for(Account account : list){

            System.out.println(account);

        }

    }

    class MyRowMapper implements RowMapper<Account>{

        @Override

        public Account mapRow(ResultSet res, int rowNum) throws SQLException {

            Account account = new Account();

            account.setId(res.getInt("id"));

            account.setName(res.getString("name"));

            account.setMoney(res.getDouble("money"));

            return account;

        }

    }

}

十. Spring 的事务传播行为

1. 报则保证多个操作在同一个事务中

PROPAGATION_REQUIRED : 默认值，如果A中有事务，使用A中的事务，如果A没有，创建一个新的事务，将操作包含进来。
PROPAGATION_SUPPORTS : 支持事务
，如果A中有事务，使用A中的事务，如果没有，则不使用事务。
PROPAGATION_MANDATORY : 如果A中有事务，使用A中的事务，如果A中没有事务，则抛异常。

2. 保证多个操作不在同一个事务中

PROPAGATION_REQUIRES_NEW : 如果A中有事务，将A的事务挂起(暂停), 创建新事务，只包含自身操作。
如果A中没有事务，则创建一个新事务，包含自身操作
PROPAGATION_NOT_SUPPORTED : 如果A中有事务，将A的事务挂起，不使用事务管理。
PROPAGATION_NEVER : 如果A中有事务，则抛异常。

3. 嵌套式事务

PROPAGATION_NESTED : 嵌套事务，如果A中有事务，按照A的事务执行，执行完毕后，设置一个保存点，执行B中的操作，如果没有异常，执行通过，如果有异常，可以选择回滚到最初始的位置，也可以回滚到保存点。

十一. Spring 声明式事务管理一 (XML)
XML 步骤:
1. 引入 aop 开发包。
2. 配置事务管理器。
3. 配置增强<tx:Advice>
4. 配置aop

# 1. XML 文件

<?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"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

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

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd

        http://www.springframework.org/schema/cache

        http://www.springframework.org/schema/cache/spring-cache.xsd

        http://www.springframework.org/schema/tx

        http://www.springframework.org/schema/tx/spring-tx.xsd">

        <!--  配置 Service  -->

        <bean id="accountService" class="com.q.tx.demo2.AccountServiceImpl">

                <property name="accountDao" ref="accountDao" />

        </bean>

        <!--  配置 DAO  -->

        <bean id="accountDao" class="com.q.tx.demo2.AccountDaoImpl">

                <property name="dataSource" ref="dataSource" />

        </bean>

        <!--  配置连接池的JDBC模板  -->

        <!--  引入属性文件  -->

        <context:property-placeholder location="classpath:jdbc.properties" />

        <!--  配置C3P0连接池  -->

        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

                <property name="driverClass" value="${jdbc.driverClass}" />

                <property name="jdbcUrl" value="${jdbc.url}" />

                <property name="user" value="${jdbc.username}" />

                <property name="password" value="${jdbc.password}" />

        </bean>

        <!--  配置事务管理  -->

        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

                <property name="dataSource" ref="dataSource" />

        </bean>

        <!--  配置事务的增强  -->

        <tx:advice id="txAdvice" transaction-manager="transactionManager">

                <tx:attributes>

                        <tx:method name="*" propagation="REQUIRED" />

                            <!--           实际开发中：            -->

<!--                        <tx:method name="save*" propagation="REQUIRED" isolation="DEFAULT" />-->

<!--                        <tx:method name="update*" propagation="REQUIRED" />-->

<!--                        <tx:method name="delete*" propagation="REQUIRED" />-->

<!--                        <tx:method name="find*" read-only="true" />-->

                </tx:attributes>

        </tx:advice>

        <!--  AOP的配置  -->

        <aop:config>

                <aop:pointcut id="pointcut1" expression="execution(* com.q.tx.demo2.AccountServiceImpl.*(..))"/>

                <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1" />

        </aop:config>

</beans>

# jdbc.propertie.xml 文件属性设置

jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql:///spring_jdbc

jdbc.username=root

jdbc.password=chaoqi

# 2. AccountDaoImpl.java 文件

package com.q.tx.demo2;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

// 转账Dao实现

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

    @Override

    public void outMoney(Integer from, Double money) {

        this.getJdbcTemplate().update("update account set money = money - ? where id = ?", money, from);

    }

    @Override

    public void inMoney(Integer to, Double money) {

        this.getJdbcTemplate().update("update account set money = money + ? where id = ?", money, to);

    }

}

# 3. AccountServiceImpl.java 文件

package com.q.tx.demo2;

// 转账的业务层实现类

public class AccountServiceImpl implements AccountService {

    // 注入 DAO

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {

        this.accountDao = accountDao;

    }

    /*

        from  : 转出账号

        to    : 转人账号

        money : 转账金额

        */

    @Override

    public void transfer(Integer from, Integer to, Double money) {

                accountDao.outMoney(from, money);

//                int i = 1/0;

                accountDao.inMoney(to, money);

    }

}

# 4. 测试文件

package com.q.tx.demo2;

// 测试类

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:tx2.xml")

public class SpringDemo1 {

    @Resource(name = "accountService")

    private AccountService accountService;

    @Test

    public void demo1(){

        accountService.transfer(1,3,100d);

    }

}

十二. Spring 声明式事务管理二 (注解方式)
注解步骤:
1. 引入 aop 开发包。
2. 配置事务管理器。
3. 开启注解事务。
4. 在业务层添加注解

# 1. XML 文件

<?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"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

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

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd

        http://www.springframework.org/schema/cache

        http://www.springframework.org/schema/cache/spring-cache.xsd

        http://www.springframework.org/schema/tx

        http://www.springframework.org/schema/tx/spring-tx.xsd">

        <!--  配置 Service  -->

        <bean id="accountService" class="com.q.tx.demo3.AccountServiceImpl">

                <property name="accountDao" ref="accountDao" />

        </bean>

        <!--  配置 DAO  -->

        <bean id="accountDao" class="com.q.tx.demo3.AccountDaoImpl">

                <property name="dataSource" ref="dataSource" />

        </bean>

        <!--  配置连接池的JDBC模板  -->

        <!--  引入属性文件  -->

        <context:property-placeholder location="classpath:jdbc.properties" />

        <!--  配置C3P0连接池  -->

        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

                <property name="driverClass" value="${jdbc.driverClass}" />

                <property name="jdbcUrl" value="${jdbc.url}" />

                <property name="user" value="${jdbc.username}" />

                <property name="password" value="${jdbc.password}" />

        </bean>

        <!--  配置事务管理器 第一步  -->

        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

                <property name="dataSource" ref="dataSource" />

        </bean>

        <!--  开启注解事务 第二步 -->

        <tx:annotation-driven transaction-manager="transactionManager" />

</beans>

# 2. AccountDaoImpl 文件

package com.q.tx.demo3;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

// 转账Dao实现

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

    @Override

    public void outMoney(Integer from, Double money) {

        this.getJdbcTemplate().update("update account set money = money - ? where id = ?", money, from);

    }

    @Override

    public void inMoney(Integer to, Double money) {

        this.getJdbcTemplate().update("update account set money = money + ? where id = ?", money, to);

    }

}

# 3. AccountServiceImpl 文件

package com.q.tx.demo3;

import org.springframework.transaction.annotation.Transactional;

// 转账的业务层实现类

// 第三步 需要在要进行事务操作的类上加  @Transactional

@Transactional

public class AccountServiceImpl implements AccountService {

    // 注入 DAO

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {

        this.accountDao = accountDao;

    }

    /*

        from  : 转出账号

        to    : 转人账号

        money : 转账金额

        */

    @Override

    public void transfer(Integer from, Integer to, Double money) {

                accountDao.outMoney(from, money);

//                int i = 1/0;

                accountDao.inMoney(to, money);

    }

}

# 4. 测试类

package com.q.tx.demo3;

// 测试类

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:tx3.xml")

public class SpringDemo1 {

    @Resource(name = "accountService")

    private AccountService accountService;

    @Test

    public void demo1(){

        accountService.transfer(1,3,100d);

    }

}

巴特西

Java - 框架之 Spring

最新文章

热门文章