2021-04-15

其他 2021-11-20 23:28:09 阅读次数: 0

Spring+MyBatis

1.创建数据库表

用户基本信息表

create  table t_user(
user_id int primary key auto_increment,
user_name varchar(20),
user_age int,
user_address varchar(30)
);

2.创建项目完善结构

3. 导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.5.RELEASE</version>
</dependency>
<!-- spring-jdbc -->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.5.RELEASE</version>
</dependency>
<!-- spring_tx -->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.1.5.RELEASE</version>
</dependency>
<!-- MyBatis依赖 -->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>
<!-- mybatis-spring 整合包 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.1</version>
</dependency>
<!-- mysql数据库驱动 -->
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.38</version>
</dependency>
<!--druid 阿里的连接池-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.7</version>
</dependency>

4. 根据数据库表创建javabean

package com.wangxing.springmybatis.bean;
public class UserBean {
    private Integer userId;
    private String userName;
    private Integer userAge;
    private String userAddress;
    public Integer getUserId() {
        return userId;
    }
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName == null ? null : userName.trim();
    }
    public Integer getUserAge() {
        return userAge;
    }
    public void setUserAge(Integer userAge) {
        this.userAge = userAge;
    }
    public String getUserAddress() {
        return userAddress;
    }
    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress == null ? null : userAddress.trim();
    }
}

5.创建数据访问接口

package com.wangxing.springmybatis.mapper;
import com.wangxing.springmybatis.bean.UserBean;
import com.wangxing.springmybatis.bean.UserBeanExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UserBeanMapper {
    long countByExample(UserBeanExample example);
    int deleteByExample(UserBeanExample example);
    int deleteByPrimaryKey(Integer userId);
    int insert(UserBean record);
    int insertSelective(UserBean record);
    List<UserBean> selectByExample(UserBeanExample example);
    UserBean selectByPrimaryKey(Integer userId);
    int updateByExampleSelective(@Param("record") UserBean record, @Param("example") UserBeanExample example);
    int updateByExample(@Param("record") UserBean record, @Param("example") UserBeanExample example);
    int updateByPrimaryKeySelective(UserBean record);
    int updateByPrimaryKey(UserBean record);
}

6.在resources创建mapper文件夹统一保存所有映射文件

7.在src/main/resources创建数据库链接字符串的资源文件【xxxxx.properties】

mydata.properties
mydriver = com.mysql.jdbc.Driver
myurl = jdbc:mysql://127.0.0.1:3306/test
myusername = root
mypassword = 123456

8.在src/main/resources配置MyBatis核心配置文件【mybatis-config.xml】中的内容融入Spring配置文件[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"
       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">
    <!-- 配置自动扫描service包 -->
    <context:component-scan base-package="com.wangxing.springmybatis.service.impl"></context:component-scan>
    <!--配置加载mydata.properties-->
    <context:property-placeholder location="classpath:mydata.properties"></context:property-placeholder>
    <!--配置数据源-->
    <!-- com.alibaba.druid.pool.DruidDataSource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${mydriver}"></property>
        <property name="url" value="${myurl}"></property>
        <property name="username" value="${myusername}"></property>
        <property name="password" value="${mypassword}"></property>
    </bean>
    <!-- 配置SqlSessionFactory -->
    <!-- org.mybatis.spring.SqlSessionFactoryBean-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
        <!--注入sql映射文件路径-->
        <property name="mapperLocations" value="classpath:mapper/UserBeanMapper.xml"></property>
    </bean>
    <!--配置扫描数据库访问接口包，创建数据库访问接口对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.wangxing.springmybatis.mapper"></property>
    </bean>
</beans>

9. 创建业务访问接口及其实现类

package com.wangxing.springmybatis.service;
import com.wangxing.springmybatis.bean.UserBean;
import java.util.List;
public interface UserService {
    public void insertUser(UserBean userBean);
    public void updateUser(UserBean userBean);
    public void deleteUser(int userid);
    public UserBean selectUserById(int userid);
    public List<UserBean> selectUser();
}
package com.wangxing.springmybatis.service.impl;
import com.wangxing.springmybatis.bean.UserBean;
import com.wangxing.springmybatis.mapper.UserBeanMapper;
import com.wangxing.springmybatis.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service("userService")
public class UserServiceImpl implements UserService {
    @Autowired
    private UserBeanMapper userBeanMapper;
    @Override
    public void insertUser(UserBean userBean) {
        userBeanMapper.insert(userBean);
    }
    @Override
    public void updateUser(UserBean userBean) {
        userBeanMapper.updateByPrimaryKey(userBean);
    }
    @Override
    public void deleteUser(int userid) {
        userBeanMapper.deleteByPrimaryKey(userid);
    }
    @Override
    public UserBean selectUserById(int userid) {
        return userBeanMapper.selectByPrimaryKey(userid);
    }
    @Override
    public List<UserBean> selectUser() {
        return userBeanMapper.selectByExample(null);
    }
}

10. 测试代码

package com.wangxing.springmybatis.test;
import com.wangxing.springmybatis.bean.UserBean;
import com.wangxing.springmybatis.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
public class TsetMain {
    public static void main(String[] args) {
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService)ac.getBean("userService");
        /*
        //测试添加
        UserBean userBean=new UserBean();
        userBean.setUserName("zhangsan");
        userBean.setUserAge(23);
        userBean.setUserAddress("西安");
        userService.insertUser(userBean);
        */
        //测试修改
        /*
        UserBean userBean=new UserBean();
        userBean.setUserId(1);
        userBean.setUserName("lisi");
        userBean.setUserAge(24);
        userBean.setUserAddress("北京");
        userService.updateUser(userBean);
         */
        //测试根据id查询
        //UserBean userBean1=userService.selectUserById(1);
        //System.out.println(userBean1.getUserName());
         /*
        //测试查询所有
        List<UserBean> userBeanList=userService.selectUser();
        for (UserBean userBean:userBeanList){
            System.out.println(userBean.getUserName());
        }
        */
        userService.deleteUser(1);
    }
}

1. 什么事务?

对数据库的一系列操作中，保证同时成功或者同时失败。不能出现成部分成功，失败部分的情况。而这一些列操作称为数据库的事务。

2. 事务的特性

数据库的事务有4大特征：

原子性：指事务是一个不可分割的工作单位,事务的操作要么都发生,要么都不发生.

一致性：事务前后数据的完整性必须保持一致。

隔离性：指多个用户并发访问数据库时,一个用户的事务不能被其他用户的事务干扰,多个并发之间的数据要相互隔离。

持久性：指一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来即使数据库发生故障也不应该对其又任何影响。简称ACID。其中隔离性最重要。

3. 事务的隔离级别

如果不考虑隔离性,可能会引发如下问题:

脏读:指一个事务读取到了另一个事务未提交的数据。

不可重复读:在一个事务内读取表中某一行数据,多次读取结果不同(一个事务读取到的另外一个事务提交的数据)

虚读(幻读):时指一个事务内读取到了别的事务插入的数据,导致前后读取不一致。

使用Java操作的时候设置隔离级别由高到低分别为：

Serializable:可避免脏读、不可重复读、虚读情况的发生。

Repeatable read:可避免脏读、不可重复读情况发生。(可重复读)

Read committed:可避免脏读情况的发生。(读已提交)

Read uncommitted:最低级别,以上情况均为无法保证。(读未提交)

值得一提的是：大多数数据库默认的事务隔离级别是Read committed，比如Sql Server , Oracle。Mysql的默认隔离级别是Repeatable read。

Java的JDBC对事务的隔离级别操作

在Java中，可以通过Connection对象来设置数据库的隔离级别，以及控制事务。

Connection中支持的设置隔离级别的常量：

设置数据库的隔离级别：

例如:

Connection conn=DBConnection.getConnection();

设置事物的隔离级别

conn.setTransactionIsolation(Connection.TRANSANCTION_READ_COMMITTED);

获取数据库的隔离级别：

Java的JDBC对事务的操作

1、在操作数据库之前，先取消数据库的自动提交：

2、当数据库出现问题的时候，回滚事务

3、当数据库操作一切都正常，提交事务

4.Spring的事务管理器

Spring提供的事务控制的接口：PlatformTransactionManager其中提供了三个方法：

根据dao层（持久层/数据访问层）使用的不同的框架，PlatformTransactionManager 的主要实现类大致如下：

DataSourceTransactionManager：适用于使用JDBC和MyBatis进行数据持久化操作的情况。

HibernateTransactionManager：适用于使用Hibernate进行数据持久化操作的情况。

5.具体事务管理操作【声明式事务管理】

1. 基于xml方式的事物管理操作

1.数据库中创建t_account账户表，模拟转账，演示spring的事务控制。

create table t_account(
account_id int primary key auto_increment,
user_name varchar(20),
money int
);
insert  into  t_account values(null,'刘能',10000);
insert  into  t_account values(null,'赵四',10000);

2. 创建项目完成项目结构，导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.5.RELEASE</version>
</dependency>
<!-- spring-jdbc -->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.5.RELEASE</version>
</dependency>
<!-- spring_tx -->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.1.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.1.5.RELEASE</version>
</dependency>
<!-- MyBatis依赖 -->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>
<!-- mybatis-spring 整合包 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.1</version>
</dependency>
<!-- mysql数据库驱动 -->
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.38</version>
</dependency>
<!--druid 阿里的连接池-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.7</version>
</dependency>

3. 创建数据访问接口

package com.wangxing.spring.mapper;
import java.util.Map;
//数据访问接口
public interface TransferMapper {
    // 加钱
    public void addMoney(Map param);
    // 减钱
    public void lessMoney(Map  param);
}

4. 创建数据访问接口对应的SQL映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wangxing.spring.mapper.TransferMapper">
    <update id="addMoney" parameterType="hashMap">
        update t_account set money = money + #{number} where user_name = #{username}
    </update>
    <update id="lessMoney" parameterType="hashMap">
        update t_account set money = money - #{number} where user_name = #{username}
    </update>
</mapper>

5. 创建业务访问类，并提供具体的业务方法

package com.wangxing.spring.service;
import com.wangxing.spring.mapper.TransferMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
@Service("transferService")
public class TransferService {
    @Autowired
    private TransferMapper transferMapper;
    /**
     * 转账方法
     * @throws Exception
     */
    public void transfer()throws Exception{
        Map<String,Object> liuneng=new HashMap<String,Object>();
        liuneng.put("username","刘能");
        liuneng.put("number",1000);
        transferMapper.lessMoney(liuneng);
        //int a=10/0;
        Map<String,Object> zhaosi=new HashMap<String,Object>();
        zhaosi.put("username","赵四");
        zhaosi.put("number",1000);
        transferMapper.addMoney(zhaosi);
    }
}

6. 创建数据库连接文件【mydata.properties】

mydriver = com.mysql.jdbc.Driver
myurl = jdbc:mysql://127.0.0.1:3306/test
myusername = root
mypassword = 123456

7. 创建Spring配置文件

<?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:tx="http://www.springframework.org/schema/tx"
       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/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 配置自动扫描service包 -->
    <context:component-scan base-package="com.wangxing.spring.service"></context:component-scan>
    <!--配置加载mydata.properties-->
    <context:property-placeholder location="classpath:mydata.properties"></context:property-placeholder>
    <!--配置数据源-->
    <!-- com.alibaba.druid.pool.DruidDataSource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${mydriver}"></property>
        <property name="url" value="${myurl}"></property>
        <property name="username" value="${myusername}"></property>
        <property name="password" value="${mypassword}"></property>
    </bean>
    <!-- 配置SqlSessionFactory -->
    <!-- org.mybatis.spring.SqlSessionFactoryBean-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
        <!--注入sql映射文件路径-->
        <property name="mapperLocations" value="classpath:mapper/TransferMapper.xml"></property>
    </bean>
    <!--配置扫描数据库访问接口包，创建数据库访问接口对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.wangxing.spring.mapper"></property>
    </bean>
    <!-- 配置事務管理 -->
    <!--1.创建事务管理器对象-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--2.创建事务-->
    <tx:advice id="txAdvice1" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="transfer"/>
        </tx:attributes>
    </tx:advice>
    <!--3.通过aop将上面创建好的事物，作用到指定的业务方法中 -->
    <aop:config>
        <aop:pointcut id="point1" expression="execution(* com.wangxing.spring.service.TransferService.transfer())"/>
        <aop:advisor advice-ref="txAdvice1" pointcut-ref="point1"></aop:advisor>
    </aop:config>
</beans>

2.基于注解方式的事物管理操作

1.在需要使用事务的业务类或者业务处理方法上添加@Transactional

  业务类上配置@Transactional表示当前业务类中的所有方法全部存在事务处理

  业务处理方法上配置@Transactional表示只有当前业务处理方法上存在事务处理

package com.wangxing.spring.service;
import com.wangxing.spring.mapper.TransferMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.HashMap;
import java.util.Map;
@Service("transferService")
@Transactional
public class TransferService {
    @Autowired
    private TransferMapper transferMapper;
    /**
     * 转账方法
     * @throws Exception
     */
    public void transfer()throws Exception{
        Map<String,Object> liuneng=new HashMap<String,Object>();
        liuneng.put("username","刘能");
        liuneng.put("number",1000);
        transferMapper.lessMoney(liuneng);
        int a=10/0;
        Map<String,Object> zhaosi=new HashMap<String,Object>();
        zhaosi.put("username","赵四");
        zhaosi.put("number",1000);
        transferMapper.addMoney(zhaosi);
    }
}

2. Spring配置文件中开启事务注解

<?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:tx="http://www.springframework.org/schema/tx"
       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/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 配置自动扫描service包 -->
    <context:component-scan base-package="com.wangxing.spring.service"></context:component-scan>
    <!--配置加载mydata.properties-->
    <context:property-placeholder location="classpath:mydata.properties"></context:property-placeholder>
    <!--配置数据源-->
    <!-- com.alibaba.druid.pool.DruidDataSource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${mydriver}"></property>
        <property name="url" value="${myurl}"></property>
        <property name="username" value="${myusername}"></property>
        <property name="password" value="${mypassword}"></property>
    </bean>
    <!-- 配置SqlSessionFactory -->
    <!-- org.mybatis.spring.SqlSessionFactoryBean-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
        <!--注入sql映射文件路径-->
        <property name="mapperLocations" value="classpath:mapper/TransferMapper.xml"></property>
    </bean>
    <!--配置扫描数据库访问接口包，创建数据库访问接口对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.wangxing.spring.mapper"></property>
    </bean>
    <!-- 配置事務管理 -->
    <!--1.创建事务管理器对象-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--开启事务管理注解-->
    <!--<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>-->
    <!-- 由于tx:annotation-driven的配置事务管理器的属性transaction-manager的默认值是transactionManager,
         我们创建的事务管理器对象的名称也是transactionManager，因此在配置tx:annotation-driven元素时
         transaction-manager属性是不用写
    -->
    <tx:annotation-driven></tx:annotation-driven>
</beans>

猜你喜欢

转载自blog.csdn.net/weixin_53123681/article/details/115718392
今日推荐
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
周排行
Family Tree 题解
BZOJ 1093 最大半连通子图 SCC + DP
幂等处理
Spring----学习（2）----XML 配置Bean 自动装配
SQL Server 远程更新目标表数据
HIbernate3.6 环境搭建
特殊符号正则表达式
【Linux】第一章 进程的理解
843. n-皇后问题（dfs+输出各种情况）
空间数据库2
每日归档
更多
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022