`

MyBatis3 之增删改查操作

 
阅读更多

MyBatis3  之  CRUD：

jar包就不上了，主要看代码。先总览一下文件结构：

MyBatis3 之增删改查操作

然后是代码：

1）configuration.xml     ， MyBatis主配置文件

 

01 <?xml version="1.0" encoding="UTF-8"?>
02 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
03 "http://mybatis.org/dtd/mybatis-3-config.dtd">
04  
05 <!-- 注意：每个标签必须按顺序写，会提示错误：-->
06 <configuration>
07     <!-- 属性配置 -->
08     <properties resource="jdbc.properties"/>
09      
10     <!-- 设置缓存和延迟加载等等重要的运行时的行为方式 -->
11     <settings>
12         <!-- 设置超时时间，它决定驱动等待一个数据库响应的时间  -->
13         <setting name="defaultStatementTimeout" value="25000"/>
14     </settings>
15      
16     <!-- 别名 -->
17     <typeAliases>
18         <typeAlias alias="User" type="com.mybatis.model.User"/>
19     </typeAliases>
20      
21     <environments default="development">
22         <!-- environment 元素体中包含对事务管理和连接池的环境配置 -->
23         <environment id="development">
24             <transactionManager type="JDBC" />
25             <dataSource type="POOLED">
26                 <property name="driver" value="${driver}" />
27                 <property name="url" value="${url}" />
28                 <property name="username" value="${username}" />
29                 <property name="password" value="${password}" />
30             </dataSource>
31         </environment>
32     </environments>
33      
34     <!-- ORM映射文件 -->
35     <mappers>
36         <mapper resource="com/mybatis/model/UserSqlMap.xml" />
37     </mappers>
38      
39 </configuration>

 

 

 2)jdbc.properties

 

1 driver=com.mysql.jdbc.Driver
2 url=jdbc:mysql://localhost:3306/mybatis
3 username=root
4 password=123456

 

3)log4j.properties

 

 

1 log4j.rootLogger=DEBUG,A1
2 # \u8f93\u51fa\u5230\u63a7\u5236\u53f0
3 log4j.appender.A1=org.apache.log4j.ConsoleAppender
4 log4j.appender.A1.layout=org.apache.log4j.PatternLayout
5 log4j.appender.A1.layout.ConversionPattern=%d{yyyy-MM-dd HH\:mm\:ss} [\u65E5\u5FD7\u4FE1\u606F] %m%n

 

4）User .java

 

 

01 package com.mybatis.model;
02  
03 import java.io.Serializable;
04  
05 @SuppressWarnings("serial")
06 public class User implements Serializable {
07      
08     private int id;
09     private String userName;
10     private String password;
11      
12     public User(){
13     }
14      
15     public int getId() {
16         return id;
17     }
18     public void setId(int id) {
19         this.id = id;
20     }
21     public String getUserName() {
22         return userName;
23     }
24     public void setUserName(String userName) {
25         this.userName = userName;
26     }
27     public String getPassword() {
28         return password;
29     }
30     public void setPassword(String password) {
31         this.password = password;
32     }
33  
34 }

 

5)UserSqlMap.xml

 

 

01 <?xml version="1.0" encoding="UTF-8"?>
02 <!DOCTYPE mapper    
03 PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"    
04 "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">    
05     
06 <!-- namespace用于java代码调用时识别指定xml的mapper文件 -->
07 <mapper namespace="com.mybatis.model.User">
08     <!-- 配置ORM映射 -->
09     <resultMap type="User" id="user_orm">
10         <id property="id" column="id"/>
11         <result property="userName" column="userName"/>
12         <result property="password" column="password"/>
13     </resultMap>
14      
15     <!-- 用来定义可重用的SQL代码段 -->
16     <sql id="demo_sql">
17        userName,password
18     </sql>
19      
20     <insert id="inser_user" parameterType="User">
21         <!-- include 引用可重用的SQL代码段 -->
22         INSERT INTO USER(<include refid="demo_sql"/>) VALUES(#{userName},#{password})
23     </insert>
24      
25     <update id="update_user" parameterType="User">
26         UPDATE USER SET userName=#{userName} ,password=#{password}  WHERE id=#{id}
27     </update>
28      
29     <update id="delete_user" parameterType="int">
30         DELETE FROM USER WHERE id=#{id}
31     </update>
32    
33     <select id="selectAll_user" useCache="false" flushCache="true"resultMap="user_orm">
34         SELECT * FROM USER
35     </select>
36      
37     <!-- 使用map传人多个参数 -->
38     <select id="selectList_user" useCache="false" flushCache="true" parameterType="map"resultMap="user_orm">
39         SELECT * FROM USER LIMIT #{pageNow},#{pageSize}
40     </select>
41      
42     <select id="selectById_user" parameterType="int" resultType="User">
43         SELECT * FROM USER WHERE id= #{id}
44     </select>
45      
46     <select id="selectCount_user"  resultType="int">
47         SELECT count(*) FROM USER
48     </select>
49      
50     <select id="selectByName_user" parameterType="String" resultType="User">
51         SELECT * FROM USER WHERE userName= #{userName}
52     </select>
53      
54 </mapper>

 

6)SessionFactoryUtil.java  MyBatis工具类，用于创建SqlSessionFactory

 

 

01 package com.mybatis.sessionfactory;
02  
03 import java.io.IOException;
04 import java.io.Reader;
05  
06 import org.apache.ibatis.io.Resources;
07 import org.apache.ibatis.session.SqlSession;
08 import org.apache.ibatis.session.SqlSessionFactory;
09 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
10  
11 public class SessionFactoryUtil {
12      
13     private static final String RESOURCE = "Configuration.xml";
14     private static SqlSessionFactory sqlSessionFactory = null;
15     private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();
16  
17     static {
18         Reader reader = null;
19         try {
20             reader = Resources.getResourceAsReader(RESOURCE);
21         } catch (IOException e) {
22             throw new RuntimeException("Get resource error:"+RESOURCE, e);
23         }
24  
25         sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
26     }
27      
28     /**
29      * Function  : 获得SqlSessionFactory
30      */
31     public staticSqlSessionFactory getSqlSessionFactory(){  
32         returnsqlSessionFactory;  
33     }
34      
35     /**
36      * Function  : 重新创建SqlSessionFactory
37      */
38     public static void rebuildSqlSessionFactory(){
39         Reader reader = null;
40         try {
41             reader = Resources.getResourceAsReader(RESOURCE);
42         } catch (IOException e) {
43             throw new RuntimeException("Get resource error:"+RESOURCE, e);
44         }
45  
46         sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
47     }
48      
49     /**
50      * Function  : 获取sqlSession
51      */
52     public static SqlSession getSession(){
53         SqlSession session = threadLocal.get();
54          
55         if(session!=null){
56             if(sqlSessionFactory == null){
57                 getSqlSessionFactory();
58             }
59             //如果sqlSessionFactory不为空则获取sqlSession，否则返回null
60             session = (sqlSessionFactory!=null) ? sqlSessionFactory.openSession(): null;
61         }
62          
63         return session;
64     }
65      
66     /**
67      * Function  : 关闭sqlSession
68      */
69     public static void closeSession(){
70         SqlSession session = threadLocal.get();
71         threadLocal.set(null);
72         if(session!=null){
73             session.close();
74         }
75     }
76 }

 

7)UserDao interface

 

 

01 package com.mybatis.dao;
02  
03 import java.util.List;
04  
05 import com.mybatis.model.User;
06  
07 public interface UserDao {
08      
09     public User load(int id);
10     public void add(User user);
11     public void update(User user);
12     public void delete(int id);
13     public User findByName(String userName);
14     public List<User>  queryAllUser();
15     public List<User> list(int pageNow,int pageSize);
16     public int getAllCount();
17      
18 }

 

8)UserDaoImpl

 

 

01 package com.mybatis.dao.implment;
02  
03 import java.util.HashMap;
04 import java.util.List;
05 import java.util.Map;
06  
07 import org.apache.ibatis.session.SqlSession;
08  
09 import com.mybatis.dao.UserDao;
10 import com.mybatis.model.User;
11 import com.mybatis.sessionfactory.SessionFactoryUtil;
12  
13  
14 public class UserDaoImpl implements UserDao {
15      
16     public User load(int id){
17         SqlSession session = SessionFactoryUtil.getSqlSessionFactory().openSession();
18         User user = (User) session.selectOne("com.mybatis.model.User.selectById_user", id);
19         session.close();
20         return user;
21     }
22  
23     public void add(User user) {
24         SqlSession session = SessionFactoryUtil.getSqlSessionFactory().openSession();
25         session.insert("com.mybatis.model.User.inser_user", user);
26         session.commit();
27         session.close();
28     }
29      
30     public void update(User user){
31         SqlSession session = SessionFactoryUtil.getSqlSessionFactory().openSession();
32         session.update("com.mybatis.model.User.update_user", user);
33         session.commit();
34         session.close();
35     }
36      
37     public void delete(int id){
38         SqlSession session = SessionFactoryUtil.getSqlSessionFactory().openSession();
39         session.delete("com.mybatis.model.User.delete_user", id);
40         session.close();
41     }
42      
43     public User findByName(String userName){
44         SqlSession session = SessionFactoryUtil.getSqlSessionFactory().openSession();
45         User user = (User)session.selectOne("com.mybatis.model.User.selectByName_user", userName);
46         session.close();
47         return user;
48     }
49      
50     @SuppressWarnings("unchecked")
51     public List<User> queryAllUser() {
52         SqlSession session = SessionFactoryUtil.getSqlSessionFactory().openSession();
53         List<User> list = session.selectList("com.mybatis.model.User.selectAll_user");
54         session.close();
55         return list;
56     }
57      
58     @SuppressWarnings("unchecked")
59     public List<User> list(int pageNow , int pageSize){
60         SqlSession session = SessionFactoryUtil.getSqlSessionFactory().openSession();
61         Map<String,Object> params = new HashMap<String ,Object>();
62         params.put("pageNow", pageNow);
63         params.put("pageSize", pageSize);
64         List<User> list = session.selectList("com.mybatis.model.User.selectList_user", params);
65         session.close();
66         return list;
67     }
68      
69     public int getAllCount(){
70         SqlSession session =SessionFactoryUtil.getSqlSessionFactory().openSession();
71         intcount = (Integer) session.selectOne("com.mybatis.model.User.selectCount_user");
72         session.close();
73         return count;
74     }
75      
76 }

 

9)测试类：

 

 

01 package com.mybatis.dao.implment;
02  
03 import java.util.List;
04  
05 import org.junit.Test;
06  
07 import com.mybatis.dao.UserDao;
08 import com.mybatis.model.User;
09  
10 public class UserDaoTest {
11      
12     private UserDao userDao = new UserDaoImpl();
13      
14     @Test
15     public void testLoad(){
16         User u = userDao.load(1);
17         if(u!=null){
18             System.out.println("UserId:"+u.getId()+"  UserName:"+u.getUserName()+"  Password:"+u.getPassword());
19         }
20         else{
21             System.out.println("id不存在！！");
22         }
23     }
24      
25     @Test
26     public void testAdd(){
27         User user = new User();
28         user.setUserName("admin5");
29         user.setPassword("123456");
30         userDao.add(user);
31     }
32      
33     @Test
34     public void testUpdate(){
35         User user = new User();
36         user.setId(2);
37         user.setUserName("manager");
38         user.setPassword("123456");
39         userDao.update(user);
40     }
41      
42     @Test
43     public void testQueryAllUser(){
44         List<User> list = userDao.queryAllUser();
45         if(list!=null&list.size()>0){
46             for(User u:list){
47                 System.out.println("UserId:"+u.getId()+"  UserName:"+u.getUserName()+"  Password:"+u.getPassword());
48             }
49         }
50     }
51      
52     @Test
53     public void testFindByName(){
54         User u = userDao.findByName("admin");
55         if(u!=null){
56             System.out.println("UserId:"+u.getId()+"  UserName:"+u.getUserName()+"  Password:"+u.getPassword());
57         }
58         else{
59             System.out.println("用户名不存在！！");
60         }
61     }
62      
63     @Test
64     public void testList(){
65         List<User> list = userDao.list(1, 4);
66         if(list!=null&list.size()>0){
67             for(User u:list){
68                 System.out.println("UserId:"+u.getId()+"  UserName:"+u.getUserName()+"  Password:"+u.getPassword());
69             }
70         }
71     }
72      
73     @Test
74     public void testGetAllCount(){
75             System.out.println("All Count : "+userDao.getAllCount());
76     }
77      
78     @Test
79     public void testDelete(){
80         userDao.delete(3);
81     }
82  
83 }

 

10)执行testFindByName()：

 

MyBatis3 之增删改查操作

分享到：
| session.flush()的使用
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Mybatis通用增删改查

    在实际开发中，为了提高代码的复用性和减少重复工作，开发者通常会实现一套通用的增删改查模板，这就是“Mybatis通用增删改查”的概念。 1. **基础 DaoImpl 概念** Dao（Data Access Object）接口是Java中用于...

    SpringBoot整合MyBatis Plus实现增删改查教程

    本文详细介绍了如何使用 Spring Boot 框架和 MyBatis Plus 实现增删改查操作的教程。MyBatis Plus 提供了许多实用的功能来简化数据库交互，例如自动将 Java 对象与数据库表对应，自动生成 SQL 语句等。

    mybatis3 增删改查 基本操作(CURD)

    总的来说，MyBatis3的增删改查操作通过XML配置文件中的SQL语句进行，结合Mapper接口和Service层，能够灵活地完成数据库的CRUD操作。这种设计提高了代码的可读性和可维护性，降低了数据库操作的复杂度。在项目开发中...

    通用mybatis-MySQL增删改查CRUD源码

    总结来说，"通用mybatis-MySQL增删改查CRUD源码"提供了一套便捷的数据库操作方案，通过MyBatis框架与MySQL数据库的配合，实现了高效、可复用的CRUD功能，大大减轻了开发者的负担。在实际项目中，这样的源码可以作为...

    Springboot+mybatis登录注册增删改查

    以上就是Spring Boot+Mybatis构建登录注册增删改查系统的详细过程，通过这个项目，开发者可以深入理解Spring Boot的自动配置原理，以及Mybatis如何与Spring Boot结合实现数据库操作。在实际开发中，还需要考虑异常...

    springMVC+mybatis实现登录和增删改查

    这些脚本在项目启动前执行，确保数据库中有必要的表和数据，便于登录和后续的增删改查操作。 **6. 数据库设计** 项目可能包含了多个实体，例如学生（Student）、成绩（Grades）和用户（User），这些实体对应数据库...

    Mybatis基本应用实现增删改查

    在本文中，我们将深入探讨如何使用Mybatis来实现基本的数据库增删改查（CRUD）操作。 首先，我们需要在项目中引入Mybatis的依赖。通常，这可以通过Maven或Gradle来完成。在Maven的pom.xml文件中，添加以下依赖： `...

    spring+mybatis实现数据增删改查

    在Java Web开发中，数据增删改查（CRUD）是最基础的操作，涵盖了创建（Create）、读取（Read）、更新（Update）和删除（Delete）四种数据库操作。Spring与MyBatis的结合，使得这些操作变得非常简洁和高效。 1. **...

    Spring Mvc+Mybatis框架组合增删改查

    在实现增删改查功能时，开发者可以为每个数据库操作创建对应的Mapper方法，如insert、update、delete和select。这些方法可以接受参数，如实体对象或Map，返回值通常是受影响的行数或查询结果。对于查询，Mybatis支持...

    基于jsp+Servlet+mybatis实现简单增删改查的图书信息系统

    这个系统具备基础的图书信息增删改查（CRUD）功能，并且实现了分页展示，同时也包含了用户登录模块。下面我们将详细解析这些关键知识点。 1. **JSP（JavaServer Pages）**： JSP是Java的一个动态网页技术，允许...

    mybatis增删改查基础jar包

    在本压缩包中，包含了 MyBatis 基础运行所需的核心组件和其他依赖库，用于实现基本的增删改查操作。 1. `mybatis-3.1.1-javadoc.jar`：这是 MyBatis 框架的 Java 文档，包含所有类和接口的详细说明，对于开发者来说...

    MyBatis入门之增删改查源码

    在本文中，我们将深入探讨如何使用MyBatis进行基本的增删改查操作，并了解必要的配置和依赖。 首先，要开始使用MyBatis，你需要在项目中引入相应的jar包。这些jar包通常包括MyBatis的核心库、...

    spring+springmvc+mybatis架构整合增删改查

    本文将详细讲解如何整合Spring、SpringMVC和MyBatis进行增删改查操作。 首先，`tb_user.sql`文件通常包含数据库表的创建脚本。在SSM架构中，MyBatis会与数据库进行交互，`tb_user`可能是我们的用户表，用于存储用户...

    mybatis_crud增删改查数据库操作.zip

    在本示例中，"mybatis_crud增删改查数据库操作.zip" 提供了一个使用MyBatis进行CRUD（Create、Read、Update、Delete）操作的教程。通过解压这个压缩包，我们可以看到一个名为"mybatis_day03_crud"的目录，这通常包含...

    servlet+mybatis做的增删改查

    3. **增删改查操作**： - **创建（Create）**：创建新的数据记录，通常涉及`insert`语句，MyBatis通过Mapper接口的`insert()`方法实现。 - **读取（Read）**：获取数据记录，可能使用`select`语句，可通过`select...

    Mybatis之增删改查

    Mybatis 是一款流行的Java持久层框架，它简化了数据库与Java应用之间的交互，使得开发者能够更专注于SQL本身，而不是繁琐的...通过学习和掌握Mybatis的基本增删改查操作，开发者可以高效地处理与数据库相关的业务逻辑。

    Mybatis实现增删改查

    在Java Web应用中，Mybatis常用于处理数据库操作，如增删改查（CRUD）。下面我们将详细讨论如何使用Mybatis来实现这些基本操作。 一、Mybatis的架构与核心组件 Mybatis主要由以下几个核心组件组成： 1. **...

    SpringBoot+mybatis+增删改查完整源码

    在本项目中，我们主要探讨的是如何利用SpringBoot框架与Mybatis进行数据库的增删改查操作。SpringBoot以其简洁的配置和快速的启动能力，成为现代Java开发中的热门选择，而Mybatis作为轻量级的持久层框架，提供灵活的...

    mybatis-plus增删改查分页

    这个入门教程旨在帮助初学者快速理解并掌握如何使用Mybatis-Plus进行数据库的增删改查（CRUD）以及分页操作。 1. **Mybatis-Plus简介** Mybatis-Plus是一个对Mybatis的增强工具，它在Mybatis的基础上做了很多自动...

    mybatis入门之简单增删改查

    在深入探讨MyBatis的简单增删改查操作之前，我们先了解一下MyBatis的基本概念和架构。 MyBatis的核心组件包括：XML配置文件、Mapper接口及Mapper XML文件、SqlSessionFactory和SqlSession。XML配置文件主要用于设置...

Magicbox
Global site tag (gtag.js) - Google Analytics