SpringJDBC与MyBatis

最新推荐文章于 2024-08-16 10:14:14 发布
最新推荐文章于 2024-08-16 10:14:14 发布
阅读量1.2k 收藏
点赞数
文章标签： java 数据库 python
原文链接：https://my.oschina.net/langgege/blog/686230
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

SpringJDBC与MyBatis;实体类属性与数据库表字段名不一致的解决方法;

--------------------------------------------------------------------------------------------------------------------

springjdbc
一.springjdbc是什么?
 - spring框架对jdbc api的封装，使用起来更加简单.比如，不用考虑获得连接与关闭连接等等。

二.如何使用?
step1. 配置DataSource。
step2. 配置JdbcTemplate。
step3. 调用JdbcTemplate提供的方法。

1.    <!-- 配置DataSource -->
    <bean id="ds" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="#{jdbc.driverClass}"/>
        <property name="url" value="#{jdbc.url}"/>
        <property name="username" value="#{jdbc.user}"/>
        <property name="password" value="#{jdbc.password}"/>
        <property name="maxActive" value="#{jdbc.MaxActive}"/>
        <property name="initialSize" value="#{jdbc.InitialSize}"/>
    </bean>

2.    <!-- 配置JdbcTemplate -->
    <bean id="jt" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="ds"/>
    </bean>

3.
@Repository
public class UserDao {
    @Resource(name="jt")
    private JdbcTemplate jt;
    
    public void save(User user){
        String sql = "INSERT INTO l_user "
                + "VALUES(l_user_seq.nextval,?,? )";
        jt.update(sql,new Object[]{user.getName(),user.getAge()});
    }
    
    /*
     * 需要写一个RowMapper接口的类,该类规定了如何将结果集中的
     * 一条记录转换成相应的java对象(比如User对象)
     */
    public List<User> findAll(){
        List<User> users = new ArrayList<User>();
        String sql = "SELECT *FROM L_USER ";
        users = jt.query(sql,new UserRowMapper());
        return users;
    }
    
    class UserRowMapper implements RowMapper<User>{
        /*
         * rst:结果集;
         * index:记录的下标,从0开始
         * @see org.springframework.jdbc.core.RowMapper#mapRow(java.sql.ResultSet, int)
         */
        public User mapRow(ResultSet rs, int index) throws SQLException {
            User user = new User();
            user.setId(rs.getInt("id"));
            user.setName(rs.getString("name"));
            user.setAge(rs.getInt("age"));
            return user;
        }        
    }
    
    public User findById(int id){
        User user = null;
        String sql = "SELECT *FROM l_user "
                + "WHERE  id=? ";
        user = jt.queryForObject(sql, new Object[]{id},new UserRowMapper());
        return user;
    }
    /*
     * 这样写查询不到数据时不会报异常
     */
    public User findById2(int id){
        User user = null;
        String sql = "SELECT *FROM l_user "
                + "WHERE  id=? ";
        List<User> users = jt.query(sql,new Object[]{id},new UserRowMapper());
        if(users!=null && users.size()>0){
            return users.get(0);
        }
        return user;
    }
    
    public void update(User user){
        String sql = "UPDATE l_user "
                + "SET name=?,age=? WHERE ID=?";
        jt.update(sql,new Object[]{user.getName(),user.getAge(),user.getId()});
    }
    
    public void delete(int id){
        String sql = "DELETE FROM l_user "
                + "WHERE id=?";
        jt.update(sql,new Object[]{id});
    }
    
    /**
     * 获得总的记录数.
     * 建议使用queryForObject方法.
     * 不建议使用queryForInt方法.
     * @return
     */
    public int getTotalRow(){
        String sql = "SELECT COUNT(*)FROM l_user";
        return jt.queryForObject(sql, Integer.class);
    }
}
------------------------------------------------------------------------------------------------------------------------
MyBatis简介
iBatis—>MyBatis

- 作用:对数据库进行操作
JDBC—>JdbcTemplate—>MyBatis

MyBatis是对JDBC技术的封装.
- 封装了获取连接,生成Statement,执行SQL过程
- 封装了SQL参数设置过程(将参数设置到#{xx})
- 封装了将结果集映射成实体对象过程(resultType指定,名称对应)


编程步骤:

- 导入mybatis包+数据库驱动包(mybatis-3.3.3.jar  ojdbc14-10.2.0.4.0.jar)
- 添加一个SqlMapConfig.xml主配置文件
- 根据表写实体类/在Mapper.xml配置文件中编写SQL/利用MyBatis调用SQL

SqlMapConfig.xml:
<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE configuration   PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"          
                        "http://ibatis.apache.org/dtd/ibatis-3-config.dtd">
<configuration>
    <environments default="environment">
        <environment id="environment">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" 
                    value="oracle.jdbc.OracleDriver" />
                <property name="url"
                    value="jdbc:oracle:thin:@localhost :1521:xe"/>
                <property name="username" value="system" />
                <property name="password" value="12345" />
            </dataSource>
        </environment>
    </environments>

    <!-- 加载SQL定义文件 -->
    <mappers>
        <mapper resource="UserMapper.xml" />
    </mappers>
</configuration> 

实体类:
public class User implements Serializable{
    private Integer id;
    private String name;
    private Integer age;
    ...get/set方法    
}

在UserMapper.xml配置文件中编写SQL:
<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE mapper PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"      
 "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">
 <mapper namespace="com.tedu.dao.UserDAO">
     <!-- 
         parameterType:参数值类型
         resultType:结果集类型
      -->
     <select id="findById" parameterType="int" resultType="com.tedu.entity.User">
         SELECT * FROM l_user
         WHERE id=#{id}
     </select>
     
     <select id="findAll" resultType="com.tedu.entity.User">
         SELECT * FROM l_user
     </select>
     
     <insert id="saveUser" parameterType="com.tedu.entity.User">
         INSERT INTO l_user
         (id,name,age)
         VALUES
          
         <!-- 参数的名字指实体类里的属性名 -->
         (l_user_seq.nextval,#{name},#{age})
     </insert>
     
     <update id="updateUser" parameterType="com.tedu.entity.User">
         UPDATE l_user
         SET name=#{name},age=#{age}
         WHERE id=#{id}
     </update>
     
     <delete id="deleteUser" parameterType="int">
         DELETE FROM l_user
         WHERE id=#{id}
     </delete>
     
     <!-- 按name字段模糊查询 -->
     <select id="findLikeName" parameterType="String" resultType="com.tedu.entity.User">
         SELECT * FROM l_user
         WHERE name LIKE #{name}
     </select>
     
     <select id="findName" parameterType="int" resultType="map">
         SELECT ID,NAME
         FROM l_user
         WHERE ID=#{id}
     </select>
     
     <select id="findNames" resultType="map">
         SELECT ID,NAME
         FROM l_user
     </select>
     
     <select id="findAllUsers" resultType="map">
         SELECT ID,NAME,AGE
         FROM l_user
     </select>
 </mapper>

利用MyBatis调用SQL:
一.Util:
public class MyBatisUtil {
    public static SqlSession getSession() throws Exception{
        /*
         * SqlSessionFactoryBuilder
         * SqlSessionFactory
         * SqlSession
         */
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //加载SqlMapConfig.xml主配置文件
        String conf = "SqlMapConfig.xml";
        Reader reader = Resources.getResourceAsReader(conf);
        
        //SqlSessionFactory
        SqlSessionFactory factory = builder.build(reader);
        
        //SqlSession
        SqlSession session = factory.openSession();
        return session;
    }
}

测试类:
public class TestUser {
    @Test
    //测试获取SqlSession,findById
    public void test1() throws Exception{
        SqlSession session = MyBatisUtil.getSession();
        System.out.println(session);
        //使用SqlSession执行SQL操作
        User user = session.selectOne("findById",2);
        if(user != null){
            System.out.println(user);
            System.out.println(user.getName());
            System.out.println(user.getAge());
        }
        session.close();
    }
    
    @Test
    //测试findAll
    public void test2() throws Exception{
        SqlSession session = MyBatisUtil.getSession();
        List<User> users = session.selectList("findAll");        
        for(User u:users){
            System.out.println(u.getId());
            System.out.println(u.getName());
            System.out.println(u.getAge());
        }
        session.close();
    }
    
    @Test
    //测试添加
    public void test3() throws Exception{
        SqlSession session = MyBatisUtil.getSession();
        User user = new User();
        //user.setId(10);用序列
        user.setName("MySQL");
        user.setAge(20);
        
        //执行insert
        session.insert("saveUser",user);
        //增删改需要手动提交事务
        session.commit();
        session.close();
    }
    
    @Test
    //测试更新
    public void test4() throws Exception{
        SqlSession session = MyBatisUtil.getSession();
        User user = new User();
        user.setId(1);
        user.setName("DAMEN");
        user.setAge(30);
        //返回值为更新的行数
        int rows = session.update("updateUser",user);
        if(rows>=1){
            System.out.println("更新成功!更新了"+rows+"行!");
        }else{
            System.out.println("更新失败!");
        }
        session.commit();
        session.close();
    }
    
    @Test
    //测试删除
    public void test5() throws Exception{
        SqlSession session = MyBatisUtil.getSession();
        int rows = session.delete("deleteUser",22);
        if(rows>=1){
            System.out.println("删除成功!删除了"+rows+"行!");
        }else{
            System.out.println("删除失败!");
        }
        session.commit();
        session.close();
    }
    
    @Test
    //测试模糊查询
    public void test6() throws Exception{
        SqlSession session = MyBatisUtil.getSession();
        List<User> users = session.selectList("findLikeName", "M%");
        if(users!=null){
            for(User u:users){
                System.out.println(u.getId());
                System.out.println(u.getName());
                System.out.println(u.getAge());
            }
        }
        session.close();
    }
    
    @Test
    //测试map查询结果
    public void test7() throws Exception{
        SqlSession session = MyBatisUtil.getSession();
        Map<String,Object> map = session.selectOne("findName",23);
        if(map!=null){
            System.out.println(map);
            //查询出的map中的key为字段名,记录为value
            System.out.println(map.get("ID")+","+map.get("NAME"));
        }                
        session.close();
    }
    
    @Test
    //测试map查询结果
    public void test8() throws Exception{
        SqlSession session = MyBatisUtil.getSession();
        List<Map<String,Object>> maps = session.selectList("findNames");
        if(maps!=null){
            for(Map<String,Object> m:maps){
                //查询出的map中的key为字段名,记录为value
                System.out.println(m.get("ID")+","+m.get("NAME"));
            }        
        }                
        session.close();
    }
    
    @Test
    //测试返回list查询结果
    public void test9() throws Exception{
        SqlSession session = MyBatisUtil.getSession();
        List<Map<String,Object>> maps = session.selectList("findAllUsers");
        if(maps!=null){
            for(Map<String,Object> m:maps){
                //查询出的map中的key为字段名,记录为value
                System.out.println(m.get("ID")+","+m.get("NAME")+","+m.get("AGE"));
            }        
        }                
        session.close();
    }
    
    @Test
    //测试Mapper映射其接口
    public void test10() throws Exception{
        SqlSession session = MyBatisUtil.getSession();
        //根据接口生成实现对象
        UserDAO dao = session.getMapper(UserDAO.class);
        System.out.println(dao.getClass().getName());
        
        List<User> users = dao.findAll();
        if(users!=null){
            for(User u:users){
                System.out.println(u.getId()+","+u.getName()+","+u.getAge());
            }
        }
        session.close();
    }
}
------------------------
Mapper映射器（接口）

MyBatis提供了一个Mapper映射器接口规则,按规则写出的接口,MyBatis框架可以自动生成实现组件对象。
(不再需要自己写dao,只需要写实体类对应的接口即可)

UserDAO接口—》JdbcUserDAO实现类—》生成对象使用
Mapper映射器接口—》生成对象使用

映射器接口接口规则:
- 方法名参考SQL定义的id属性（保持一致）
- 方法参数类型参考SQL定义的parameterType属性（保持一致）
-方法返回类型
     - 增删改：可以是void 或 int
     - 查询：单行结果类型为resultType,多行结果类型为List
     - 将SQL定义文件元素的namespace属性指定为"包名.接口名"

/**
 * Mapper映射器接口:对应UserMapper.xml里的sql语句
 * 方法名--->id属性
 * 参数--->parameterType属性
 * 返回值类型-->增删改void或int;查询参考resultType属性
 *                 查询结果为多个的话返回值为list类型.
 * @author Administrator
 *
 */
public interface UserDAO {
    public User findById(int id);
    public List<User> findAll();
    public int saveUser(User user);
    public int updateUser(User user);
    public int deletdUser(int id);
    public List<User> findLikeName(String name);
    public Map<String,Object> findName(int id);
    public List<Map<String,Object>> findNames();
    public List<Map<String,Object>> findAllUsers();    
}
-----------------------------------------------------------------------------------------------------------
实体类属性与数据库表字段名不一致的解决方法: 
    
    <!-- 当属性名与字段名不一致的解决方法
         方法一:用别名
      -->
     <!-- <select id="findAll2"     resultMap="costMap">
         SELECT cost_id id,name,...
         FROM cost
     </select> -->
     
     <!-- 方法二:自定义属性
         利用resultMap自定义装载规则,替代resultType.
      --> 
     <select id="findAll2"     resultMap="costMap">
         SELECT *FROM cost
     </select>
     <resultMap type="com.tedu.entity.Cost" id="costMap">
         <id property="id" column="cost_id"/>
         <result property="name" column="name"/>
         <!-- ...可以省略名称一致的字段 -->
     </resultMap>
--------------------------------------------------------------------------------------------------------------------

转载于:https://my.oschina.net/langgege/blog/686230

weixin_34220179
关注
spring jdbc和mybatis对比
m0_47300610的博客
12-12 3158
一 spring jdbc是通过JdbcTemplate这个类来实现增删改查操作。 1.下面是一个例子的核心代码块 首先是核心代码块applicationContext.xml的配置，用来链接数据库 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <!--数据库驱动--> <property name="drive
spring与JDBC以及Mybatis的整合
BearGryllsMM的博客
01-29 2625
笔者列举了开发中经常用到的spring与jdbc以及spring与mybatis的整合(只列举了项目开发中经常用到的)， 希望能帮到你。 一.spring与JDBC整合 xml version="1.0" encoding="UTF-8"?> beans xmlns="http://www.springframework.org/schema/beans";  
Spring学习（六）—— SpringJDBC与MyBatis
Growing_Snake的博客
08-22 1359
SpringJDBC SpringJDBC是Spring对JDBC的封装，可以避免使用JDBC时的一些重复代码，如获取连接、关闭连接等操作。 1.导入maven依赖包 spring-webmvc，spring-jdbc， ojdbc，dbcp，junit 2.添加Spring配置文件 3.配置JdbcTemplate 4.调用JdbcTemplate的方法访问数据库 通常将JdbcTemplate注入到DAO中，方便使用。 ...
JDBC、MyBatis
最新发布
qq_53251296的博客
08-16 1870
mybatis是一个半ORM(对象关系映射)的持久层框架，他封装了JDBC，简化了数据库访问的繁琐流程，又保留了对sql的原生态操作。通过xml或注解来映射对象与sql之间的关系，帮助开发者加快了CRUD的操作。
jdbc mybatis hibernate springJDBC的一些理解
lifeneedyou的专栏
01-15 331
                       JDBC， Ibtais ，Hibernate ,SpringJDBC  是我们平时大家开发的过程中使用的比较多的几种持久化技术，具体在开发的过程中该怎么选择呢？            先来说说各自的特点，首先是JDBC，这个是Java语言提供的规范，主要就是定义一些接口和通讯类，接口定义好之后，各个数据库厂商来提供具体的实现，比如Oracle...
spring的jdbc和mybatis
iteye_19269的博客
12-08 270
引用：由于JdbcTemplate、NamedParameterJdbcTemplate、SimpleJdbcTemplate类使用DataSourceUtils获取及释放连接，而且连接是与线程绑定的，因此这些JDBC模板类是线程安全的，即JdbcTemplate对象可以在多线程中重用。   spring的JDBC： DataSourceUtils得到一个数据库连接的实现，和hibern...
JDBC-＞SpringJDBC-＞Mybatis封装JDBC
代码是程序员的语言，博客是思想的桥梁，连接你我，共享智慧之光。
01-01 1782
1、什么是JDBCJDBC（Java Data Base Connectivity, Java数据库连接） 是一种用于执行SQL语句的Java API，为多种关系数据库提供统一访问 ，它由一组用Java语言编写的类和接口组成。2、有了JDBC，程序员只需用JDBC API写一个程序，就可访问所有数据库。(常用的框架Hibernate、MyBatis底层都是JDBC，都是对JDBC的封装)
Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能
09-07
本篇文章将详细讲解如何使用Spring Boot结合Sharding-JDBC和Mybatis-Plus实现分库分表功能。 一、Sharding-JDBC简介 Sharding-JDBC是由Apache ShardingSphere项目提供的一个轻量级数据库中间件，它作为JDBC驱动...
木木的Java知识整理——JDBC与MyBatis的区别
不想当咸鱼的咸鱼不是好咸鱼
04-27 7853
看了几篇大佬的相关整理，可以总结成如下几部分。 JDBC与MyBatis的区别一、各自定义1.1 JDBC1.2 MyBatis二、JDBC与MyBatis的区别 一、各自定义 1.1 JDBC Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。 JDB...
springjdbc和mybatis区别
03-16
Spring JDBC和MyBatis都是Java中的持久化框架，但是它们有以下几个区别： 1. 技术架构：Spring JDBC是基于JDBC API的，而MyBatis则是基于ORM（对象关系映射）的。 2. SQL语句处理：Spring JDBC需要手动编写SQL语句...
Spring学习——Spring整合JDBC&mybaties
qq_43524048的博客
11-03 266
整合JDBC简介案例介绍1. 全注解方式1.1 事务管理---基于注解方式2. 基于xml方式 简介 Spring框架中提供了一个类JdbcTemplate，是对原始jdbc API的简单封装。除了这个模板类，spring框架提供了很多的操作模板类： 操作关系型数据库：JdbcTemplate,HibernateTemplate 操作redis数据库：RedisTemplate 操作消息队列：JmsTemplate 案例介绍 以银行账户管理为例，创建一个账户表Account(id,name,mone
Spring+mybatis+jdbc结合使用教程
08-15
本文档主要讲解Spring与mybatis与jdbc结合使用的方法和例子。
Spring、SpringMVC入门及整合JDBC、Mybatis
07-19
详细讲解了Spring、SpringMVC常用功能的使用，以及整合JDBC和Mybatis的共同开发，适用于新手入门
Java学习小结——Spring整合JDBC、Spring整合mybatis
qq_40796493的博客
11-18 351
文章目录Spring整合JDBC1.编码前准备2.引入数据源，数据源配置3.代码实现Spring整合Mybatis1.编码前准备2.配置2.1 基于xml配置：2.2 基于注解配置 Spring整合JDBC 1.编码前准备 建表s_user create table s_user( id number primary key, name varchar2(20), age number(2), birth date ); 创建序列，用来生成主键 creat
Spring学习（10）Spring应用之JDBC（Spring与Mybatis整合）
冯冬冬的博客
01-24 301
目录 一、导入jar 二、搭建测试环境 1、定义Student 2、定义数据库 3、定义接口 4、定义mapper 5、定义mybatis.xml 6、service层 7、spring-dao.xml文件的编写 第一步：引入jdbc.properties 第二步：接下来配置数据源， （1）Spring默认的数据源DriverManagerrDataSource （2）D...
MyBatis、Spring JDBC 和 Spring Data JPA：选择哪种持久化框架？
weixin_40642302的博客
04-14 3546
MyBatis 是一个基于Java的持久层框架。它提供的持久层框架包括SQL Maps和Data Access Objects（DAO）。MyBatis是一个支持普通SQL查询存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的XML或注解用于配置和原始映射，将接口和 Java 的POJO（Plain Old Java Objects，普通的 Java对象）映射成数据库中的记录每个MyBatis应用程序主要都是使用。
Spring和MyBatis、JDBC整合
半坡人的博客
03-13 931
文章目录Spring和MyBatis整合1.pom.xml添加依赖2.添加jar包以及开启mysql服务3.pom.xml中Build里添加(用来找到mapper.xml文件)4.创建实体类（添加构造函数，getter，setter，toString方法）5.创建Dao层以及其mapper实现类6.创建Service.interface及其实现类UserServiceImpl7.添加resourc...
SpringBoot 整合jdbc和mybatis
Lin_JunSheng的博客
11-18 1850
文章目录摘要通用配置数据库表实体类maven配置数据库配置整合JDBCmaven依赖使用测试整合MyBatismaven依赖扫描MapperMapper映射UserMapper接口UserMapper.xml 摘要 该文章主要为记录如何在SpringBoot项目中整合JDBC和MyBatis，在整合中我会使用简单的用法和测试用例，毕竟该文章目的是为了整合，而不是教大家如何去使用。希望大家多多包涵。...
Spring-Data-JDBC + Mybatis-plus 实现DDD仓储层，实现1+1 ＞= 2
weixin_43566803的博客
04-26 3750
Spring-Data-JDBC整合 Mybatis-plus **spring-data-jdbc官方文档 项目目录结构: 导入Maven依赖 <!-- mybatis-plus的代码生成器 --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-generator</
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值