Spring_Hibernate_Transaction_Annotation

1.目录结构

2.jar包

3.User

package com.cloud.spring.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * @author cloud
 * @data 2016年5月13日
 * @version 1.0
 * @description:普通的JavaBean
 */
@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    private String password;

    public User() {

    }

    public User(String name, String psd) {
        this.name = name;
        this.password = psd;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return name;
    }

    public void setUsername(String username) {
        this.name = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

 

4.UserDAO

package com.cloud.spring.dao;

import com.cloud.spring.model.User;

/**
 * @author cloud
 * @data 2016年5月13日
 * @version 1.0
 * @description:定义接口，定义规范，必须实现save方法
 */
public interface UserDAO {
    public void save(User user);
    public void delete(User user);
}

 

5.UserDAOImpl

package com.cloud.spring.dao.imp;

import javax.annotation.Resource;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Component;

import com.cloud.spring.dao.UserDAO;
import com.cloud.spring.model.User;

/**
 * 
 * @author cloud
 * @data 2016年5月13日
 * @version 1.0
 * @description:实现接口，重写方法
 */
@Component
public class UserDAOImpl implements UserDAO {
    private SessionFactory sessionFactory;
    
    
    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    
    @Resource
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public void save(User user) {
        Session s = sessionFactory.getCurrentSession();
        s.save(user);
        throw new RuntimeException("run time");
    }

    public void delete(User user) {
        System.out.println("user delete!");
    }
}

 

6.UserService

package com.cloud.spring.service;

import java.io.IOException;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.cloud.spring.dao.UserDAO;
import com.cloud.spring.model.User;

/**
 * 
 * @author cloud
 * @data 2016年5月13日
 * @version 1.0
 * @description:真正的业务处理
 */
@Component("userService")
public class UserService {

    private UserDAO userDAO;

    /**
     * propagation属性值，默认值是PREQUIRED 
     * 1.PREQUIRED：如果有了transaction就用原来的，如果没有就创建一个新的
     * 2.REQUIRES_NEW：重新创建一个transaction，原先的挂起 
     * 3.NESTED：内嵌一个transaction执行，原来的暂停，
     * 新创建一个transaction，执行完之后再执行原来的，内部的transaction异常回滚不会影响到外面的 
     * 4. readOnly = true,性能优化
     * 5.timeout = 60超时回滚，单位是秒
     * 6.rollbackFor = RuntimeException.class抛出RuntimeException异常时回滚
     * 7.noRollbackFor = IOException.class抛出IOException异常时不回滚
     * 
     * @param user
     */
    @Transactional(propagation = Propagation.REQUIRED, readOnly = false, timeout = 60, rollbackFor = RuntimeException.class, noRollbackFor = IOException.class)
    public void add(User user) {
        userDAO.save(user);
    }

    public void delete(User user) {
        userDAO.delete(user);
    }

    public UserDAO getUserDAO() {
        return userDAO;
    }

    @Resource
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }
}

 

 

7.TestSpring

package com.cloud.spring.test;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.cloud.spring.model.User;
import com.cloud.spring.service.UserService;

public class TestSpring {
    public static void main(String[] args) {
        try {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
            UserService service = (UserService)ctx.getBean("userService");
            service.add(new User("lisi","123"));
        } catch (BeansException e) {
            e.printStackTrace();
        }
    }
}

 

8.beans.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/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- Spring容器管理bean对象 -->
    <context:component-scan base-package="com.cloud.spring" />

    <!-- dataSource数据源配置 -->
    <!-- 1.配置文件路径 -->
    <bean
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations" value="classpath:jdbc.properties"></property>
    </bean>

    <!-- 2.数据库连接池的参数配置 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

    <!-- 3.单例模式 sessionFactory，并保存Hibernate配置-->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="com.cloud.spring.model" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="dialect">org.hibernate.dialect.MySQL5Dialect</prop>
                <prop key="hibernate.show_sql">true</prop>
            </props>
        </property>
    </bean>
    
    <!-- 4.将事务交给 transactionManager处理-->
    <!-- 5.在需要的类或者方法上添加@Transactional注解即可进行事务的管理 -->
    <!-- 6.这是个切面类：在方法开始的时候beginTransaction，结束的时候就Transaction.commit,如果有Runtime异常则roolBack -->
    <bean id="transactionManager"
            class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <!-- 7.开启事务管理驱动 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

 

9.jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/lpwan
jdbc.username=root
jdbc.password=root