1010cc时时彩标准版 > 三分时时彩1010CC > SpringMVC学习笔记三,框架整合小小总结

原标题:SpringMVC学习笔记三,框架整合小小总结

浏览次数:187 时间:2019-08-12

JAVAEE——spring03:spring整合JDBC和aop事务,javaeespring03

一、spring整合JDBC

spring整合JDBC

spring提供了成都百货上千模板整合Dao本事,用于简化编制程序。

 图片 1

引进相关jar包

 图片 2

spring中提供了壹个得以操作数据库的指标,JDBCTemplate(JDBC模板对象)。对象封装了jdbc才能。与DBUtils中的QueryRunner非常相像。

@Test
public void fun1() throws Exception{
//0 准备连接池
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql:///hibernate_32");
dataSource.setUser("root");
dataSource.setPassword("1234");
//1 创建JDBC模板对象
JdbcTemplate jt = new JdbcTemplate();
jt.setDataSource(dataSource);
//2 书写sql,并执行
String sql = "insert into t_user values(null,'rose') ";
jt.update(sql);

}

上述办法并从未接纳spring容器,下边演示将连接池的配置交给 Spring 管理

1、dao接口,UserDao.java

图片 3图片 4

package cn.itcast.a_jdbctemplate;

import java.util.List;

import cn.itcast.bean.User;

public interface UserDao {

    //增
    void save(User u);
    //删
    void delete(Integer id);
    //改
    void update(User u);
    //查
    User getById(Integer id);
    //查
    int getTotalCount();
    //查
    List<User> getAll();
}

View Code

2、dao实现类

package cn.itcast.a_jdbctemplate;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

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

import cn.itcast.bean.User;
//使用JDBC模板实现增删改查
public class UserDaoImpl implements UserDao {
    private JdbcTemplate jt;
    @Override
    public void save(User u) {
        String sql = "insert into t_user values(null,?) ";
        jt.update(sql, u.getName());
    }
    @Override
    public void delete(Integer id) {
        String sql = "delete from t_user where id = ? ";
        jt.update(sql,id);
    }
    @Override
    public void update(User u) {
        String sql = "update t_user set name = ? where id=? ";
        jt.update(sql, u.getName(),u.getId());
    }
    @Override
    public User getById(Integer id) {
        String sql = "select * from t_user where id = ? ";
        return jt.queryForObject(sql,new RowMapper<User>(){
            @Override
            public User mapRow(ResultSet rs, int arg1) throws SQLException {
                User u = new User();
                u.setId(rs.getInt("id"));
                u.setName(rs.getString("name"));
                return u;
            }}, id);

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

    @Override
    public List<User> getAll() {
        String sql = "select * from t_user ";
        List<User> list = jt.query(sql, new RowMapper<User>(){
            @Override
            public User mapRow(ResultSet rs, int arg1) throws SQLException {
                User u = new User();
                u.setId(rs.getInt("id"));
                u.setName(rs.getString("name"));
                return u;
            }});
        return list;
    }

  public void setJt(JdbcTemplate jt) {
      this.jt = jt;
  }

}

Spring配置

<?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="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="jdbcUrl" value="jdbc:mysql:///hibernate_crm"></property>
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="user" value="root"></property>
    <property name="password" value="123456"></property>
</bean>


<!-- 2.将JDBCTemplate放入spring容器 -->
<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 3.将UserDao放入spring容器 -->
<bean name="userDao" class="cn.itcast.a_jdbctemplate.UserDaoImpl">
    <property name="jt" ref="jdbcTemplate"></property>
</bean>
</beans>

测试类:

package cn.itcast.a_jdbctemplate;

import java.beans.PropertyVetoException;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import cn.itcast.bean.User;

//演示JDBC模板
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo {
    @Resource(name="userDao")
    private UserDao ud;

    @Test
    public void fun2() throws Exception{
        User u = new User();
        u.setName("tom");
        ud.save(u);
    }
}

JDBCDaoSupport类简化了上面的操作,不需要自己手动创建JDBCTemplate类。使用方式如下:

//使用JDBC模板实现增删改查
public class UserDaoImpl extends JdbcDaoSupport implements UserDao {
    @Override
    public void save(User u) {
        String sql = "insert into t_user values(null,?) ";
        super.getJdbcTemplate().update(sql, u.getName());
    }
}

布署文件如下:

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

<!-- 指定spring读取db.properties配置 -->
<context:property-placeholder location="classpath:db.properties"/>

<!-- 1.将连接池放入spring容器 -->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="jdbcUrl" value="jdbc:mysql:///hibernate_crm"></property>
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="user" value="root"></property>
    <property name="password" value="123456"></property>
</bean>

<!-- 3.将UserDao放入spring容器 -->
<bean name="userDao" class="cn.itcast.a_jdbctemplate.UserDaoImpl">
    <property name="dataSource" ref="dataSource"></property>
</bean>
</beans>

spring

l AOP :切面编制程序

切面:切入点 和 通知 结合

l spring aop 编程

<aop:config>

方法1:

  <aop:pointcut expression="切入点表达式" id="">

  <aop:advisor  advice-ref="通知引用" pointcut-ref="切入点的引用">

 

方法2:

   <aop:advisor  advice-ref="通知引用" pointcut="切入点表达式">

 

l AspectJ xml

<aop:config>

  <aop:aspect ref="切面类">

     <aop:pointcut>

     <aop:before>  前置

     <aop:afterReturning  returning="第二个参数名称"> 后置

     <aop:around> 环绕

     <aop:afterThrowing throwing="第二。。。"> 抛出异常

     <aop:after> 最终

 

l AspectJ annotation

@Aspect

@Pointcut("表达式")  private void xxx(){}

@Before @...

 

l 切入点表达式

<aop:pointcut expression="execution(* com.itheima.crm.*.service..*.*(..))" id="">

 

Spring 注解式注册 bean:

大致分为以下几步:

  1. 拉开 context 空间支撑
  2. 开启自动扫描功用,内定扫描包路线
  3. 使用申明配置 bean (使用@Component 评释)
  4. 给 bean 注入属性(基本项目和援引类型)
  5. 设置 bean 的生命周期
  6. 设置 bean 的成效域(默以为单例)


详细:

1 . 开启 context 空间支撑

2 . 开启自动扫描功能,钦点扫描路线(表达:扫描路线能够安装多少个,中间使用,隔离,扫描路线包罗钦赐包和子包内部存储器有的类)

<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
            ">
<!-- 这里指定的是带有注解配置的bean,基本所有的类都要配置,dao,service -->
<context:component-scan base-package="com.msym.dao,com.msym.service"></context:component-scan>
</beans>

对于分化的层有三种分歧的 bean 注解:

一、spring整合JDBC

  1.spring提供了过多模板整合Dao技能

  图片 5

读取外界的Properties配置

在db.properties中配备数据库连接新闻,防止名称争论,提出加前缀:

jdbc.jdbcUrl=jdbc:mysql:///hibernate_crm
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=123456

布局文件:

<!-- 指定spring读取db.properties配置 -->
<context:property-placeholder location="classpath:db.properties" />

  <!-- 1.将连接池放入spring容器 -->
  <bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
  <property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
  <property name="driverClass" value="${jdbc.driverClass}" ></property>
  <property name="user" value="${jdbc.user}" ></property>
  <property name="password" value="${jdbc.password}" ></property>
</bean>

终极完全配置

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

<!-- 指定spring读取db.properties配置 -->
<context:property-placeholder location="classpath:db.properties" />

<!-- 1.将连接池放入spring容器 -->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
<property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
<property name="driverClass" value="${jdbc.driverClass}" ></property>
<property name="user" value="${jdbc.user}" ></property>
<property name="password" value="${jdbc.password}" ></property>
</bean>


<!--&lt;!&ndash; 2.将JDBCTemplate放入spring容器 &ndash;&gt;-->
<!--<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" >-->
<!--<property name="dataSource" ref="dataSource" ></property>-->
<!--</bean>-->

<!-- 3.将UserDao放入spring容器 -->
<bean name="userDao" class="cn.itcast.a_jdbctemplate.UserDaoImpl" >
<!-- <property name="jt" ref="jdbcTemplate" ></property> -->
<property name="dataSource" ref="dataSource" ></property>
</bean>
</beans>

事务管理

  • @Repository 用于数据层完成类标记
  • @Service用于业务层的实现类的注释
  • @Controller用于调整层达成类的申明

  1.spring提供了无数模板整合Dao手艺

  图片 6

  2.spring中提供了二个方可操作数据库的对象.对象封装了jdbc能力.

   JDBCTemplate => JDBC模板对象

   与DBUtils中的QueryRunner极其相似.

        //0 准备连接池
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql:///xieyupeng");
        dataSource.setUser("root");
        dataSource.setPassword("1234");
        //1 创建JDBC模板对象
        JdbcTemplate jt = new JdbcTemplate();
        jt.setDataSource(dataSource);
        //2 书写sql,并执行
        String sql = "insert into t_user values(null,'rose') ";
        jt.update(sql);

spring中aop事务

spring封装了事务管理代码,因为在区别平台,操作工作的代码各分歧,spring提供了三个PlatformTransactionManager 接口。

只顾:在spring中玩事务管理.最为大旨的指标正是TransactionManager对象

2.1 追忆职业

l 事务:一组职业操作ABCD,要么全体打响,要么全体不成功。

l 特性:ACID

原子性:整体

一致性:完成

隔离性:并发

持久性:结果

l 隔开难题:

脏读:贰个业务读到另一个事务未有交到的数据

不得重复读:贰个专门的学业读到另三个专门的学业已交给的数额(update)

虚读(幻读):二个事情读到另四个事情已交给的数量(insert)

l 隔开分离等级:

read uncommitted:读未提交。存在3个难题

read committed:读已交付。化解脏读,存在2个难点

repeatable read:可重新读。化解:脏读、不可重复读,存在1个难题。

serializable :串行化。都解决,单事务。

图片 7

 

l mysql 事务操作--简单

ABCD 一个事务

Connection conn = null;

try{

  //1 获得连接

  conn = ...;

  //2 开启事务

  conn.setAutoCommit(false);

  A

  B

  C

  D

  //3 提交事务

  conn.commit();

} catche(){

  //4 回滚事务

  conn.rollback();

}

 

l mysql 事务操作--Savepoint

需求:AB(必须),CD(可选)

Connection conn = null;

Savepoint savepoint = null;  //保存点,记录操作的当前位置,之后可以回滚到指定的位置。(可以回滚一部分)

try{

  //1 获得连接

  conn = ...;

  //2 开启事务

  conn.setAutoCommit(false);

  A

  B

  savepoint = conn.setSavepoint();

  C

  D

  //3 提交事务

  conn.commit();

} catche(){

  if(savepoint != null){   //CD异常

     // 回滚到CD之前

     conn.rollback(savepoint);

     // 提交AB

     conn.commit();

  } else{   //AB异常

     // 回滚AB

     conn.rollback();

  }

}

 

4.1 为 bean 注入轻松类型:

  2.spring中提供了多少个足以操作数据库的对象.对象封装了jdbc本事.

   JDBCTemplate => JDBC模板对象

   与DBUtils中的QueryRunner极其相似.

        //0 准备连接池
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql:///xieyupeng");
        dataSource.setUser("root");
        dataSource.setPassword("1234");
        //1 创建JDBC模板对象
        JdbcTemplate jt = new JdbcTemplate();
        jt.setDataSource(dataSource);
        //2 书写sql,并执行
        String sql = "insert into t_user values(null,'rose') ";
        jt.update(sql);

  3.整合步骤

spring管理职业的习性介绍

2.2 事务管理介绍

  1. 在属性名上方声明该属性自动装配 @Autowired
  2. 在属性名上方注脚该属性注入的值 @Value(value)

  3.整合步骤

   3.1 导包

   4 2:4代表:图片 8

   2代表:com.springsource.org.apache.commons.logging-1.1.1.jar、com.springsource.org.apache.log4j-1.2.15.jar(老版本要导入的,导入能够保险一定能运作)

   spring-test、spring-aop、junit4类库

   c3p0连接池、JDBC驱动

   spring-jdbc、spring-tx事务

1、事务的隔离品级

  • 1 读未提交
  • 2 读已交由
  • 4 可再度读
  • 8 串行化

2.2.1 导入jar包

transaction  -->  tx

图片 9

 

 

 

【注意:证明自动装配属性值不要求提供对应属性的setter方法】

   3.1 导包

   4 2:4代表:图片 10

   2代表:com.springsource.org.apache.commons.logging-1.1.1.jar、com.springsource.org.apache.log4j-1.2.15.jar(老版本要导入的,导入可以确定保障一定能运作)

   spring-test、spring-aop、junit4类库

   c3p0连接池、JDBC驱动

   spring-jdbc、spring-tx事务

   3.2 希图数据库(七个字段id(自增进)和name就能够)

2、是还是不是只读

  • true 只读
  • false 可操作

2.2.2 多个拔尖接口

图片 11

 

 

l PlatformTransactionManager  平台作业管理器,spring要管理专门的学问,必须利用专门的工作管理器

张开张营业务配置时,必须布局事务处理器

l TransactionDefinition:事务实际情况(事务定义、事务属性),spring用于显然职业具体详细的情况,

比如:隔断品级、是不是只读、超时时间 等

拓展专门的工作配置时,务必布署详细的情况。spring将配置项封装到该对象实例。

l TransactionStatus:事务状态,spring用于记录当前政工作运动市场价格况。比如:是或不是有保存点,事务是或不是产生。

spring底层遵照情状进行对应操作。

 

例如:

   3.2 筹算数据库(八个字段id(自增进)和name就能够)

   3.3 书写Dao

//使用JDBC模板实现增删改查
public class UserDaoImpl extends JdbcDaoSupport implements UserDao {
    @Override
    public void save(User u) {
        String sql = "insert into t_user values(null,?) ";
        super.getJdbcTemplate().update(sql, u.getName());
    }
    @Override
    public void delete(Integer id) {
        String sql = "delete from t_user where id = ? ";
        super.getJdbcTemplate().update(sql,id);
    }
    @Override
    public void update(User u) {
        String sql = "update  t_user set name = ? where id=? ";
        super.getJdbcTemplate().update(sql, u.getName(),u.getId());
    }
    @Override
    public User getById(Integer id) {
        String sql = "select * from t_user where id = ? ";
        return super.getJdbcTemplate().queryForObject(sql,new RowMapper<User>(){
            @Override
            public User mapRow(ResultSet rs, int arg1) throws SQLException {
                User u = new User();
                u.setId(rs.getInt("id"));
                u.setName(rs.getString("name"));
                return u;
            }}, id);

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

    @Override
    public List<User> getAll() {
        String sql = "select * from t_user  ";
        List<User> list = super.getJdbcTemplate().query(sql, new RowMapper<User>(){
            @Override
            public User mapRow(ResultSet rs, int arg1) throws SQLException {
                User u = new User();
                u.setId(rs.getInt("id"));
                u.setName(rs.getString("name"));
                return u;
            }});
        return list;
    }
}

3、事务的流传行为

图片 12

2.2.3 PlatformTransactionManager  事务管理器

l 导入jar包:须求时平台作业管理器的落实类

图片 13

 

 

l 常见的作业管理器

DataSourceTransactionManager  ,jdbc开采时专门的学业管理器,选拔JdbcTemplate

HibernateTransactionManager,hibernate开辟时工作管理器,整合hibernate

图片 14

 

 

 

l api详解

TransactionStatus getTransaction(TransactionDefinition definition) ,事务处理器 通过“事务实际情况”,获得“事务状态”,进而管住事务。

void commit(TransactionStatus status)  依据意况提交

void rollback(TransactionStatus status) 依照景况回滚

 

@Autowired
@Value("msym")
private String msg;

   3.3 书写Dao

//使用JDBC模板实现增删改查
public class UserDaoImpl extends JdbcDaoSupport implements UserDao {
    @Override
    public void save(User u) {
        String sql = "insert into t_user values(null,?) ";
        super.getJdbcTemplate().update(sql, u.getName());
    }
    @Override
    public void delete(Integer id) {
        String sql = "delete from t_user where id = ? ";
        super.getJdbcTemplate().update(sql,id);
    }
    @Override
    public void update(User u) {
        String sql = "update  t_user set name = ? where id=? ";
        super.getJdbcTemplate().update(sql, u.getName(),u.getId());
    }
    @Override
    public User getById(Integer id) {
        String sql = "select * from t_user where id = ? ";
        return super.getJdbcTemplate().queryForObject(sql,new RowMapper<User>(){
            @Override
            public User mapRow(ResultSet rs, int arg1) throws SQLException {
                User u = new User();
                u.setId(rs.getInt("id"));
                u.setName(rs.getString("name"));
                return u;
            }}, id);

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

    @Override
    public List<User> getAll() {
        String sql = "select * from t_user  ";
        List<User> list = super.getJdbcTemplate().query(sql, new RowMapper<User>(){
            @Override
            public User mapRow(ResultSet rs, int arg1) throws SQLException {
                User u = new User();
                u.setId(rs.getInt("id"));
                u.setName(rs.getString("name"));
                return u;
            }});
        return list;
    }
}

   3.4 spring配置

   依赖关系

<!-- 1.将连接池放入spring容器 -->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
    <property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
    <property name="driverClass" value="${jdbc.driverClass}" ></property>
    <property name="user" value="${jdbc.user}" ></property>
    <property name="password" value="${jdbc.password}" ></property>
</bean>


<!-- 2.将JDBCTemplate放入spring容器 -->
<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" >
    <property name="dataSource" ref="dataSource" ></property>
</bean>

<!-- 3.将UserDao放入spring容器 -->
<bean name="userDao" class="cn.itcast.a_jdbctemplate.UserDaoImpl" >
    <!-- <property name="jt" ref="jdbcTemplate" ></property> -->
    <property name="dataSource" ref="dataSource" ></property>
</bean>

spring管理职业格局

2.2.4 TransactionStatus

图片 15

 

那样设置之后就无需再提供该属性的 get/set 方法了,

   3.4 spring配置

   重视关系

<!-- 1.将连接池放入spring容器 -->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
    <property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
    <property name="driverClass" value="${jdbc.driverClass}" ></property>
    <property name="user" value="${jdbc.user}" ></property>
    <property name="password" value="${jdbc.password}" ></property>
</bean>


<!-- 2.将JDBCTemplate放入spring容器 -->
<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" >
    <property name="dataSource" ref="dataSource" ></property>
</bean>

<!-- 3.将UserDao放入spring容器 -->
<bean name="userDao" class="cn.itcast.a_jdbctemplate.UserDaoImpl" >
    <!-- <property name="jt" ref="jdbcTemplate" ></property> -->
    <property name="dataSource" ref="dataSource" ></property>
</bean>

   3.5 测试

//演示JDBC模板
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo {
    @Resource(name="userDao")
    private UserDao ud;

    @Test
    public void fun2() throws Exception{
        User u = new User();
        u.setName("tom");
        ud.save(u);
    }
    @Test
    public void fun3() throws Exception{
        User u = new User();
        u.setId(2);
        u.setName("jack");
        ud.update(u);

    }

    @Test
    public void fun4() throws Exception{
        ud.delete(2);
    }

    @Test
    public void fun5() throws Exception{
        System.out.println(ud.getTotalCount());
    }

    @Test
    public void fun6() throws Exception{
        System.out.println(ud.getById(1));
    }

    @Test
    public void fun7() throws Exception{
        System.out.println(ud.getAll());
    }

}

测量检验碰到搭建

图片 16图片 17

package com.yyb.dao;

public interface AccountDao {
    //加钱
    void increaseMoney(Integer id, Double money);
    //减钱
    void decreaseMoney(Integer id, Double money);
}

AccountDao

图片 18图片 19

package com.yyb.dao;

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

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao  {
    @Override
    public void increaseMoney(Integer id, Double money) {
        getJdbcTemplate().update("update t_account set money = money ? where id = ? ", money,id);
    }
    @Override
    public void decreaseMoney(Integer id, Double money) {
        getJdbcTemplate().update("update t_account set money = money-? where id = ? ", money,id);
    }

}

AccountDaoImpl

图片 20图片 21

package com.yyb.service;

public interface AccountService {
    //转账方法
    void transfer(Integer from, Integer to, Double money);
}

AccountService

图片 22图片 23

package com.yyb.service;

import com.yyb.dao.AccountDao;


public class AccountServiceImpl implements AccountService {
    private AccountDao ad;

    @Override
    public void transfer(Integer from, Integer to, Double money) {
        //减钱
        ad.decreaseMoney(from,money);
        //加钱
        ad.increaseMoney(to,money);
    }

    public void setAd(AccountDao ad) {
        this.ad = ad;
    }
}

AccountServiceImpl

图片 24图片 25

<?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" xmlns:tx="http://www.springframework.org/schema/tx"
       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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">

    <!-- 指定spring读取db.properties配置 -->
    <context:property-placeholder location="classpath:db.properties"/>
    <!-- 1.连接池 -->
    <bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!-- 2.Dao-->
    <bean name="accountDao" class="com.yyb.dao.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 3.Service-->
    <bean name="accountService" class="com.yyb.service.AccountServiceImpl">
        <property name="ad" ref="accountDao"></property>
    </bean>

</beans>

applicationContext

图片 26图片 27

jdbc.jdbcUrl=jdbc:mysql:///hibernate_crm
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=123456

db.properties

图片 28图片 29

package com.yyb.app;

import com.yyb.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * Created by Administrator on 2017/8/17.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TransactionTest {
    @Autowired
   private AccountService accountService;
    @Test
    public void func1(){
        accountService.transfer(1,2,100d);
    }

}

TransactionTest

2.2.5 TransactionDefinition

图片 30

 

 

l 传播行为:在八个业务之间什么分享专门的学业。

 

PROPAGATION_REQUIRED , required , 必须  【默认值】

协助当前事情,A要是有作业,B将动用该业务。

假设A没有职业,B将创立贰个新的作业。

PROPAGATION_SUPPORTS ,supports ,支持

支撑当前政工,A即使有事情,B将动用该职业。

假设A未有专业,B将以非事务实践。

PROPAGATION_MANDATORY,mandatory ,强制

支撑当前政工,A假如有业务,B将运用该事务。

若果A无业,B将抛极度。

PROPAGATION_REQUIRES_NEW , requires_new ,必须新的

设若A有作业,将A的事情挂起,B创制三个新的事体

假如A未有职业,B创造一个新的作业

PROPAGATION_NOT_SUPPORTED ,not_supported ,不支持

如若A有事情,将A的事情挂起,B将以非事务实行

万一A未有职业,B将以非事务试行

PROPAGATION_NEVER ,never,从不

若果A有作业,B将抛至极

假设A未有职业,B将以非事务推行

PROPAGATION_NESTED ,nested ,嵌套

A和B底层采纳保存点机制,形成嵌套事务。

 

掌握:PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED

 

4.2 为 bean 注入引用数据类型:

   3.5 测试

//演示JDBC模板
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo {
    @Resource(name="userDao")
    private UserDao ud;

    @Test
    public void fun2() throws Exception{
        User u = new User();
        u.setName("tom");
        ud.save(u);
    }
    @Test
    public void fun3() throws Exception{
        User u = new User();
        u.setId(2);
        u.setName("jack");
        ud.update(u);

    }

    @Test
    public void fun4() throws Exception{
        ud.delete(2);
    }

    @Test
    public void fun5() throws Exception{
        System.out.println(ud.getTotalCount());
    }

    @Test
    public void fun6() throws Exception{
        System.out.println(ud.getById(1));
    }

    @Test
    public void fun7() throws Exception{
        System.out.println(ud.getAll());
    }

}

  4.升级内容

方式1:编码式(了解)

1.将主导业务管理器配置到spring容器,在applicationContext中布置如下代码:

    <!-- 事务核心管理器,封装了所有事务操作. 依赖于连接池 -->
    <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

2.配备TransactionTemplate模板,在applicationContext中配备如下代码:

   <!--事务模板对象-->
    <bean class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager"></property>
    </bean>

3.将业务模板注入Service

    <!-- 3.Service-->
    <bean name="accountService" class="com.yyb.service.AccountServiceImpl">
        <property name="ad" ref="accountDao"></property>
        <property name="tt" ref="transactionTemplate"></property>
    </bean>

4.在Service中调用模板

package com.yyb.service;

import com.yyb.dao.AccountDao;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;


public class AccountServiceImpl implements AccountService {
    private AccountDao ad;
    private TransactionTemplate tt;

    //匿名内部类访问外部变量得加final
    @Override
    public void transfer(final Integer from,final Integer to, Double money) {
        tt.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
                //减钱
                ad.decreaseMoney(from,money);
                //int i=1/0;
                //加钱
                ad.increaseMoney(to,money);
            }
        });
    }

    public void setAd(AccountDao ad) {
        this.ad = ad;
    }
    public void setTt(TransactionTemplate tt) {
        this.tt = tt;
    }
}

2.3 案例:转账

  1. 在属性名上方注脚该属性自动装配 @Aotuwired
  2. 在属性名上方申明该属性注入的值 @Qualifier(bean 援引的名字)

  4.进级内容

   4.1 JDBCDaoSupport

public class UserDaoImpl extends JdbcDaoSupport

图片 31

<!-- 3.将UserDao放入spring容器(继承JDBCDaoSupport,直接注入dataSourse即可) -->
<bean name="userDao" class="cn.itcast.a_jdbctemplate.UserDaoImpl" >
    <!-- <property name="jt" ref="jdbcTemplate" ></property> -->
    <property name="dataSource" ref="dataSource" ></property>
</bean>

方式2:xml配置(aop)

简言之明了正是把通告织入到对象对象中,形成二个代理对象。譬如通告要拓展事务处理,指标对象要拓展工作管理。那么代理对象则把事务管理和事务管理合到了协同。SpringAOP给大家策画了二个业务公告,目的对象即大家的service。所以只须要配置一下就能够了。

 1、必要导包aop、aspect、aop结盟、weaving织入包

图片 32

2.导入新的封锁(tx)

 图片 33

beans: 最宗旨约束;context:读取properties配置约束;aop:配置aop约束;tx:配置事务通知约束

3.配备通告和配备将通报织入目的

<!-- 事务核心管理器,封装了所有事务操作. 依赖于连接池 -->
    <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置事务通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager" >
        <tx:attributes>
            <!-- 以方法为单位,指定方法应用什么事务属性
                isolation:隔离级别
                propagation:传播行为
                read-only:是否只读
             -->
            <tx:method name="transfer" isolation="DEFAULT" propagation="REQUIRED" read-only="false"/>
            <!--上面的方式只适用单个方法,当我们业务有很多个方法都要操作事务时,则要配置很多个,可以使用下面的通配符配置方式-->
            <tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="persist*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="modify*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="remove*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
            <tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
        </tx:attributes>
    </tx:advice>
    <!--配置织入-->
    <aop:config>
        <aop:pointcut id="txPc" expression="execution(* com.yyb.service.*ServiceImpl.*(..))"/>
        <!--配置切面-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPc"/>
    </aop:config>

2.3.1 搭建景况

【注意:注明自动装配属性值无需提供对应属性的setter方法】

   4.1 JDBCDaoSupport

public class UserDaoImpl extends JdbcDaoSupport

图片 34

<!-- 3.将UserDao放入spring容器(继承JDBCDaoSupport,直接注入dataSourse即可) -->
<bean name="userDao" class="cn.itcast.a_jdbctemplate.UserDaoImpl" >
    <!-- <property name="jt" ref="jdbcTemplate" ></property> -->
    <property name="dataSource" ref="dataSource" ></property>
</bean>

   4.1 读取外界的Properties配置

    db.properties 注意加前缀(越来越好界别,幸免重名)

jdbc.jdbcUrl=jdbc:mysql:///hibernate_32
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=1234

<!-- 指定spring读取db.properties配置 -->
<context:property-placeholder location="classpath:db.properties"  />

<!-- 1.将连接池放入spring容器 -->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
    <property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
    <property name="driverClass" value="${jdbc.driverClass}" ></property>
    <property name="user" value="${jdbc.user}" ></property>
    <property name="password" value="${jdbc.password}" ></property>
</bean>

艺术3:申明配置(aop)

1.导包(同上)

2.导入新的束缚(tx),同上

3.敞开注明管理作业

<?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" xmlns:tx="http://www.springframework.org/schema/tx"
       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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">

    <!-- 指定spring读取db.properties配置 -->
    <context:property-placeholder location="classpath:db.properties"/>

    <!-- 事务核心管理器,封装了所有事务操作. 依赖于连接池 -->
    <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--开启使用注解管理aop事务-->
    <tx:annotation-driven/>
    <!-- 1.连接池 -->
    <bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!-- 2.Dao-->
    <bean name="accountDao" class="com.yyb.dao.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 3.Service-->
    <bean name="accountService" class="com.yyb.service.AccountServiceImpl">
        <property name="ad" ref="accountDao"></property>
    </bean>

</beans>

4.用到声明

    @Transactional(isolation = Isolation.REPEATABLE_READ,propagation = Propagation.REQUIRED,readOnly = false)
    public void transfer(Integer from,Integer to, Double money) {

在点子上加评释,要是格局太多,嫌麻烦的话,可以在类上加,假若有些方法不适应,再在措施上写一份就可以。

package com.yyb.service;

import com.yyb.dao.AccountDao;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Transactional(isolation = Isolation.REPEATABLE_READ,propagation = Propagation.REQUIRED,readOnly = false)
public class AccountServiceImpl implements AccountService {
    private AccountDao ad;

    @Override
    @Transactional(isolation = Isolation.DEFAULT,propagation = Propagation.REQUIRED,readOnly = false)
    public void transfer(Integer from,Integer to, Double money) {
        //减钱
        ad.decreaseMoney(from,money);
        //int i=1/0;
        //加钱
        ad.increaseMoney(to,money);
    }

    public void setAd(AccountDao ad) {
        this.ad = ad;
    }

}

 更详尽请参照他事他说加以考察:

2.3.1.1 创建表

create database ee19_spring_day03;

use ee19_spring_day03;

create table account(

  id int primary key auto_increment,

  username varchar(50),

  money int

);

insert into account(username,money) values('jack','10000');

insert into account(username,money) values('rose','10000');

 

例如:

本文由1010cc时时彩标准版发布于三分时时彩1010CC,转载请注明出处:SpringMVC学习笔记三,框架整合小小总结

关键词:

上一篇:java多线程同步,Java中如何解决线程安全问题

下一篇:1010cc时时彩标准版绝对路径与相对路线难点,w