精华内容
下载资源
问答
  • 公司用的系统比较老,不能上框架,因此用原生jdbc。 原来的程序员写的一条一条插入,又慢又容易报error。 没办法,老夫上网找了资料,重新改写程序。 一、传入list,进行切割 // 数据传输,为提高插入效率,对数据...

    公司用的系统比较老,不能上框架,因此用原生jdbc。
    原来的程序员写的一条一条插入,又慢又容易报error。
    没办法,老夫上网找了资料,重新改写程序。

    一、传入list,进行切割

    // 数据传输,为提高插入效率,对数据进行切割
    		int ls = list.size();
            int size = 1000;
    		if (ls <= size) {
    			// 若数据量小于size时,直接插入
    			insertDulDataForSqlServer(list);
    		} else {
    			int times = (int) Math.ceil(ls / size);
    			System.out.println("总插入批次   times: " + times);
    			for (int i = 0; i <= times; i++) {
    				System.out.println("截取的开始角标" + i * size + "  截止角标" + Math.min((i + 1) * size, ls) + " min"
    						+ (i + 1) * size + " max" + ls);
    				// Math.min()方法,取较小值
    				List<Policy> subList = list.subList(i * size, Math.min((i + 1) * size, ls));
    				// 插入
    				insertDulDataForSqlServer(subList);
    			}
    		}
    

    二、执行bean转化并插入

    private void insertDulDataForSqlServer(List<Policy> list) throws SQLException {
    		//连接数据库
    		Connection conn = DBConnection();
    		try {
    				PreparedStatement stmt = conn
    					.prepareStatement("insert into dbo.BC_CONTROL_INSURANCE values(?,?,?,?,?)");
    			// 执行
    			for (Policy bean : list) {
    				preparedStatementStringSetter(stmt, 1, bean.getNo());
    				preparedStatementStringSetter(stmt, 2, "");
    				preparedStatementStringSetter(stmt, 3, bean.getIn());
    				preparedStatementStringSetter(stmt, 4, bean.getPolicy());
    				preparedStatementDateSetter(stmt, 5, bean.getDat());
    				
    				stmt.addBatch();
    
    			}
    			stmt.executeBatch();
    			System.out.println("执行插入语句:");
    			// 提交需要执行的语句
    			conn.commit();
    			stmt.close();
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				if (conn != null)
    					conn.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    
    	}
    

    到此基本结束,

    后面最多给个jdbc连接

    private Connection DBConnection() {
    
    		String url = "jdbc:microsoft:sqlserver://ip;databaseName=DB_TRANS";
    		String userString = "x";
    		String pwd = "123";
    
    		Connection conn = null;
    		try {
    			return conn = DriverManager.getConnection(url, userString, pwd);
    		} catch (SQLException e) {
    			//因为公司网络垃圾,怕连不上数据库,所以连接两次
    			try {
    				return conn = DriverManager.getConnection(url, userString, pwd);
    			} catch (SQLException e1) {
    				e1.printStackTrace();
    			}
    			e.printStackTrace();
    		}
    		return conn;
    	}
    
    展开全文
  • 原生JDBC基本不会在工作中写,已经被各种框架所代替,但是不意味着面试/笔试中不会出现,而且这也考量了一个程序员的基础是否扎实 建表 Mysql create table t_test( id BIGINT auto_increment COMMENT '主键', ...
    原生JDBC基本不会在工作中写,已经被各种框架所代替,但是不意味着面试/笔试中不会出现,而且这也考量了一个程序员的基础是否扎实

    建表 Mysql

    create table t_test(
    id BIGINT auto_increment COMMENT '主键',
    name VARCHAR(20) NOT NULL COMMENT '姓名',
    age INT NOT NULL COMMENT'年龄',
    create_time datetime NOT NULL COMMENT '创建时间',
    PRIMARY KEY (id)
    )ENGINE=INNODB;
    

    插入两条数据,用于JDBC查询

    INSERT INTO t_test(name,age,create_time) 
    values('testName',20,now());
    
    INSERT INTO t_test(name,age,create_time) 
    values('testName1',20,now());
    

    创建实体类Student

    import java.util.Date;
    
    public class Student {
    	/**
    	 * id自增长
    	 */
    	private int id;
    	/**
    	 * 姓名
    	 */
    	private String name;
    	/**
    	 * 年龄
    	 */
    	private int age;
    	/**
    	 * 创建时间
    	 */
    	private Date createTime;
    	
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public Date getCreateTime() {
    		return createTime;
    	}
    	public void setCreateTime(Date createTime) {
    		this.createTime = createTime;
    	}
    	@Override
    	public String toString() {
    		return "Student [id=" + id + ", name=" + name + ", age=" + age + ", createTime=" + createTime + "]";
    	}
    }
    

    JDBC查询数据

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    
    public class ConnectMysql {
    	public static void main(String[] args) {
    		Connection conn = null;
    		PreparedStatement pstm = null;
    		try {
    			Class.forName("com.mysql.jdbc.Driver");
    			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","root");
    			String sql = "select * from t_test where age = ?";
    			pstm = conn.prepareStatement(sql);
    			//给占位符设置值pstm.setObject(),视参数类型替换Object,占位符下标从1开始
    			pstm.setInt(1, 20);
    			ResultSet rs = pstm.executeQuery();
    			//接收多条返回值
    			List<Student> studentList = new ArrayList<Student>();
    			while(rs.next()) {
    				Student student = new Student();
    				student.setId(rs.getInt("id"));
    				student.setName(rs.getString("name"));
    				student.setAge(rs.getInt("age"));
    				student.setCreateTime(rs.getDate("create_time"));
    				studentList.add(student);
    			}
    			//遍历查询
    			for(Student student:studentList) {
    				System.out.println(student);
    			}
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}finally {
    			if(null != pstm) {
    				try {
    					pstm.close();
    				} catch (SQLException e) {
    					e.printStackTrace();
    				}
    			}
    			if(null != conn) {
    				try {
    					conn.close();
    				} catch (SQLException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}	
    }
    
    执行结果:
    Student [id=1, name=testName, age=20, createTime=2020-03-14]
    Student [id=2, name=testName1, age=20, createTime=2020-03-14]
    

    JDBC插入数据

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    import java.util.Date;
    
    public class ConnectMysql {
    	public static void main(String[] args) {
    		Connection conn = null;
    		PreparedStatement pstm = null;
    		try {
    			Class.forName("com.mysql.jdbc.Driver");
    			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","root");
    			String sql = "insert into t_test(name,age,create_time) values(?,?,?)";
    			pstm = conn.prepareStatement(sql);
    			//给占位符设置值pstm.setObject(),视参数类型替换Object,占位符下标从1开始
    			pstm.setString(1, "zhangsan");
    			pstm.setInt(2, 30);
    			pstm.setObject(3, new Date(System.currentTimeMillis()));
    			int result = pstm.executeUpdate();
    			if(result > 0) {
    				System.out.println("插入" + result + "条数据成功!");
    			}
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}finally {
    			if(null != pstm) {
    				try {
    					pstm.close();
    				} catch (SQLException e) {
    					e.printStackTrace();
    				}
    			}
    			if(null != conn) {
    				try {
    					conn.close();
    				} catch (SQLException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}	
    }
    
    执行结果:
    插入1条数据成功!
    

    在这里插入图片描述

    展开全文
  • 原生jdbc示例 与spring JDBC 示例

    千次阅读 2018-08-14 23:33:27
    原生jdbc与spring整合 JDBC介绍 JDBC API 允许用户访问任何形式的表格数据,尤其是存储在关系数据库中的数据。 执行流程: 连接数据源,如:数据库。 为数据库传递查询和更新指令。 处理数据库响应并返回的...

    个人博客:https://suveng.github.io/blog/​​​​​​​

    原生jdbc与spring整合

    JDBC介绍

    JDBC API 允许用户访问任何形式的表格数据,尤其是存储在关系数据库中的数据。

    执行流程:

    • 连接数据源,如:数据库。
    • 为数据库传递查询和更新指令。
    • 处理数据库响应并返回的结果。

    Two-tier-Architecture-for-Data-Access

    首先需要把jar包导进来,mysql-connector-java-6.0.6.jar,如果用maven把一下依赖添加进pom.xml

    <!--mysql connnector-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>6.0.6</version>
    </dependency>
    <!--end-->
    

    JDBC 编程步骤

    1. 加载驱动程序:
    2. 获得数据库连接
    3. 创建Statement\PreparedStatement对象:

    正在加载类com.mysql.jdbc.Driver'。 这已被弃用。 新的驱动程序类是com.mysql.cj.jdbc.Driver’。 驱动程序通过SPI自动注册,通常不需要手动加载驱动程序类。

    准备数据表

    CREATE DATABASE suveng DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
    
    use suveng;
    create table user(
    	id int NOT NULL PRIMARY KEY auto_increment,
    	name VARCHAR(50) ,
    	age int 
    ) DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
    

    原生JDBC示例:

    /**
     * @author Veng Su 1344114844@qq.com
     * @date 2018/8/14 21:03
     */
    
    public class DBUtils {
        private String url;
        private String username;
        private String password;
    
        public String getUrl() {
            return url;
        }
    
        public void setUrl(String url) {
            this.url = url;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public static void main(String[] args) throws ClassNotFoundException, SQLException {
            DBUtils dbUtils=new DBUtils();
            dbUtils.setUrl("jdbc:mysql://localhost:3306/suveng?serverTimezone=Asia/Shanghai&characterEncoding=utf8");
            dbUtils.setUsername("root");
            dbUtils.setPassword("root");
    //        1. 加载驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            //2. 获得数据库连接
            Connection conn = DriverManager.getConnection(dbUtils.getUrl(), dbUtils.getUsername(), dbUtils.getPassword());
            //3.操作数据库,实现增删改查
            //预编译SQL,减少sql执行
            String sql="INSERT INTO user (name, age) VALUES ('suveng', 22)";
            PreparedStatement  stmt = conn.prepareStatement(sql);
            stmt.executeUpdate();
    
            ResultSet rs2 = stmt.executeQuery("SELECT * FROM user");
            //如果有数据,rs.next()返回true
            while(rs2.next()){
                System.out.println(rs2.getString("name")+" 年龄:"+rs2.getInt("age"));
            }
        }
    }
    

    这是使用原生的jdbc链接数据库和增查操作,然而我们spring已经封装了jdbc了,这样让我们的操作变得更简单。

    Spring JDBC示例

    相å³å›¾ç‰‡

    编程步骤:

    1. 配置数据源datasource
    2. 初始化jdbcTemplate
    3. 使用jdbcTemplate对数据库做增删查改
    /**
     * @author Veng Su 1344114844@qq.com
     * @date 2018/8/14 22:14
     */
    public class SpringJDBCDemo {
       @Test
        public void springJDBCTest() {
            //初始化DataSource
            DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
            driverManagerDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
            driverManagerDataSource.setUrl("jdbc:mysql://localhost:3306/suveng?serverTimezone=Asia/Shanghai&characterEncoding=utf8");
            driverManagerDataSource.setUsername("root");
            driverManagerDataSource.setPassword("root");
            //初始化jdbcTemplate
            JdbcTemplate jdbcTemplate = new JdbcTemplate(driverManagerDataSource);
            // 查询一条数据
            User user1 = jdbcTemplate.queryForObject("select * from user where id = ?", new BeanMapper(), 1);
            System.out.println(user1);
    
            // 删除
    //         jdbcTemplate.update("delete from user where id = ?", 1);
    
            // 修改
            jdbcTemplate.update("update user set name = ? where id = ?", "春花", 1);
    
            // 插入
            jdbcTemplate.update("insert into user(name,age) values( '花花', 10)");
    
            // 方式2:查询所有的数据
            List<User> list2 = jdbcTemplate.query("select * from user", new BeanMapper());
    
            for (User user : list2) {
                System.out.println(user);
            }
            // 方式1: 查询所有的数据
            List<Map<String, Object>> list = jdbcTemplate.queryForList("select * from user");
            for (Map<String, Object> map : list) {
                //  map.keySet() 用于获取所有的 key
                for (String key : map.keySet()) {
                    // 通过 key 获取到对应的 value 值
                    System.out.print(map.get(key));
                }
                // 相当于换行效果
                System.out.println();
            }
    
        }
    
        private class BeanMapper implements org.springframework.jdbc.core.RowMapper<User> {
            // 查询的时候,有可能会返回多个数据,所有的数据都会放在 rs 结果集中
            // rounum 代表的是记录的下表值
            public User mapRow(ResultSet resultSet, int i) throws SQLException {
                User user=new User();
                user.setId(resultSet.getInt("id"));
                user.setName(resultSet.getString("name"));
                user.setAge(resultSet.getInt("age"));
                return user;
            }
        }
    }
    

    测试:

    运行结果;

    1534260036681

    问题

    为什么是用jdbcTemplate需要传datasource?

    这个可以通过类图说明,初始化jdbcTemplate需要一个datasource接口

    而,DriverManagerDateSource的父类实现了dataSource接口,所以可以传进去构造。如下图。

    DriverManagerDateSource

    1534260537397

    JdbcTemplate

    1534260571749

    既然可以new 出来的实例,我们应该交给spring去管理。

    在beans.xml配置DataSource和jdbcTemplate

    <!--配置DataSource-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/suveng?serverTimezone=Asia/Shanghai &amp;characterEncoding=utf8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!--配置jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    

    配置好了,我们可以开始注入了。

    /**
     * @author Veng Su 1344114844@qq.com
     * @date 2018/8/14 22:14
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:spring/config/beans.xml")
    public class SpringJDBCDemo {
        @Resource
        JdbcTemplate jdbcTemplate;
        @Test
        public void springJDBCXMLTest(){
            // 查询一条数据
            User user1 = jdbcTemplate.queryForObject("select * from user where id = ?", new BeanMapper(), 1);
            System.out.println(user1);
    
            // 删除
    //         jdbcTemplate.update("delete from user where id = ?", 1);
    
            // 修改
            jdbcTemplate.update("update user set name = ? where id = ?", "春花", 1);
    
            // 插入
            jdbcTemplate.update("insert into user(name,age) values( ?, ?)", "花花", 1000);
    
            // 方式2:查询所有的数据
            List<User> list2 = jdbcTemplate.query("select * from user", new BeanMapper());
    
            for (User user : list2) {
                System.out.println(user);
            }
            // 方式1: 查询所有的数据
            List<Map<String, Object>> list = jdbcTemplate.queryForList("select * from user");
            for (Map<String, Object> map : list) {
                //  map.keySet() 用于获取所有的 key
                for (String key : map.keySet()) {
                    // 通过 key 获取到对应的 value 值
                    System.out.print(map.get(key));
                }
                // 相当于换行效果
                System.out.println();
            }
    
        }
        @Test
        public void springJDBCTest() {
            //初始化DataSource
            DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
            driverManagerDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
            driverManagerDataSource.setUrl("jdbc:mysql://localhost:3306/suveng?serverTimezone=Asia/Shanghai&characterEncoding=utf8");
            driverManagerDataSource.setUsername("root");
            driverManagerDataSource.setPassword("root");
            //初始化jdbcTemplate
            JdbcTemplate jdbcTemplate = new JdbcTemplate(driverManagerDataSource);
            // 查询一条数据
            User user1 = jdbcTemplate.queryForObject("select * from user where id = ?", new BeanMapper(), 1);
            System.out.println(user1);
    
            // 删除
    //         jdbcTemplate.update("delete from user where id = ?", 1);
    
            // 修改
            jdbcTemplate.update("update user set name = ? where id = ?", "春花", 1);
    
            // 插入
            jdbcTemplate.update("insert into user(name,age) values( '花花', 10)");
    
            // 方式2:查询所有的数据
            List<User> list2 = jdbcTemplate.query("select * from user", new BeanMapper());
    
            for (User user : list2) {
                System.out.println(user);
            }
            // 方式1: 查询所有的数据
            List<Map<String, Object>> list = jdbcTemplate.queryForList("select * from user");
            for (Map<String, Object> map : list) {
                //  map.keySet() 用于获取所有的 key
                for (String key : map.keySet()) {
                    // 通过 key 获取到对应的 value 值
                    System.out.print(map.get(key));
                }
                // 相当于换行效果
                System.out.println();
            }
    
        }
    
    
        private class BeanMapper implements org.springframework.jdbc.core.RowMapper<User> {
            // 查询的时候,有可能会返回多个数据,所有的数据都会放在 rs 结果集中
            // rounum 代表的是记录的下表值
            public User mapRow(ResultSet resultSet, int i) throws SQLException {
                User user=new User();
                user.setId(resultSet.getInt("id"));
                user.setName(resultSet.getString("name"));
                user.setAge(resultSet.getInt("age"));
                return user;
            }
        }
    }
    

    运行结果:

    1534260074976

    码云代码地址:

    https://gitee.com/suwenguang/SpringFrameworkDemo

    donwnload下来后,其中src/main/java/spring/my/suveng/jdbc才是本文的代码源。其他是其他文章的引用。

    结论

    这就是使用spring jdbc 的快捷之处。更多的对jdbc的探索还是需要时间去研究。加油

    展开全文
  • 原生JDBC+mybatis

    2018-09-19 21:04:00
    1.1. jdbc编程步骤: 1、 加载数据库驱动 2、 创建并获取数据库链接 3、 创建jdbc statement对象 4、 设置sql语句 5、 设置sql语句中的参数(使用preparedStatement) 6、 通过statement执行sql并获取结果 7、 ...

    1.1. jdbc编程步骤:

    1、  加载数据库驱动

    2、  创建并获取数据库链接

    3、  创建jdbc statement对象

    4、  设置sql语句

    5、  设置sql语句中的参数(使用preparedStatement)

    6、  通过statement执行sql并获取结果

    7、  对sql执行结果进行解析处理

    8、  释放资源(resultSet、preparedstatement、connection)

     

    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
    
        try {
            // 加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
    
            // 通过驱动管理类获取数据库链接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "root");
            // 定义sql语句 ?表示占位符
            String sql = "select * from user where username = ?";
            // 获取预处理statement
            preparedStatement = connection.prepareStatement(sql);
            // 设置参数,第一个参数为sql语句中参数的序号(从1开始),第二个参数为设置的参数值
            preparedStatement.setString(1, "王五");
            // 向数据库发出sql执行查询,查询出结果集
            resultSet = preparedStatement.executeQuery();
            // 遍历查询结果集
            while (resultSet.next()) {
                System.out.println(resultSet.getString("id") + "  " + resultSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

    1.1. jdbc问题总结如下:

    1、  数据库连接创建、释放频繁造成系统资源浪费,从而影响系统性能。如果使用数据库连接池可解决此问题。

    2、  Sql语句在代码中硬编码,造成代码不易维护,实际应用中sql变化的可能较大,sql变动需要改变java代码。

    3、  使用preparedStatement向占有位符号传参数存在硬编码,因为sql语句的where条件不一定,可能多也可能少,修改sql还要修改代码,系统不易维护。

    4、  对结果集解析存在硬编码(查询列名),sql变化导致解析代码变化,系统不易维护,如果能将数据库记录封装成pojo对象解析比较方便。

     

    1、  mybatis配置

    SqlMapConfig.xml,此文件作为mybatis的全局配置文件,配置了mybatis的运行环境等信息。

    mapper.xml文件即sql映射文件,文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。

    2、  通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂

    3、  由会话工厂创建sqlSession即会话,操作数据库需要通过sqlSession进行。

    4、  mybatis底层自定义了Executor执行器接口操作数据库,Executor接口有两个实现,一个是基本执行器、一个是缓存执行器。

    5、  Mapped Statement也是mybatis一个底层封装对象,它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象,sql的id即是Mapped statement的id。

    6、  Mapped Statement对sql执行输入参数进行定义,包括HashMap、基本类型、pojo,Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中,输入参数映射就是jdbc编程中对preparedStatement设置参数。

    Mapped Statement对sql执行输出结果进行定义,包括HashMap、基本类型、pojo,Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中,输出结果映射过程相当于jdbc编程中对结果的解析处理过程。

     2、搭建mybatis开发环境

    1、配置config文件sqlmapconfig.xml文件

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <!-- 和spring整合后 environments配置将废除 -->
        <environments default="development">
            <environment id="development">
                <!-- 使用jdbc事务管理 -->
                <transactionManager type="JDBC" />
                <!-- 数据库连接池 -->
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver" />
                    <property name="url"
                        value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
                    <property name="username" value="root" />
                    <property name="password" value="root" />
                </dataSource>
            </environment>
        </environments>
    </configuration>

    sqlmapconfig是mybatis核心配置文件,配置有数据库连接池,数据源,事务等等;

     

    1.1.1. #{}和${}

    #{}表示一个占位符号,通过#{}可以实现preparedStatement向占位符中设置值,自动进行java类型和jdbc类型转换。#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值,#{}括号中可以是value或其它名称。

     

    ${}表示拼接sql串,通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换, ${}可以接收简单类型值或pojo属性值,如果parameterType传输单个简单类型值,${}括号中只能是value。

     

     

    1.1.2. parameterType和resultType

    parameterType:指定输入参数类型,mybatis通过ognl从输入对象中获取参数值拼接在sql中。

    resultType:指定输出结果类型,mybatis将sql查询结果的一行记录数据映射为resultType指定类型的对象。如果有多条数据,则分别进行映射,并把对象放到容器List中

     

    1.1.3. selectOne和selectList

    selectOne查询一条记录,如果使用selectOne查询多条记录则抛出异常:

    org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 3

       at org.apache.ibatis.session.defaults.DefaultSqlSession.selectOne(DefaultSqlSession.java:70)

    selectList可以查询一条或多条记录。

    1.1. Mybatis解决jdbc编程的问题

    1、  数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能,如果使用数据库连接池可解决此问题。

    解决:在SqlMapConfig.xml中配置数据连接池,使用连接池管理数据库链接。

    2、  Sql语句写在代码中造成代码不易维护,实际应用sql变化的可能较大,sql变动需要改变java代码。

    解决:将Sql语句配置在XXXXmapper.xml文件中与java代码分离。

    3、  向sql语句传参数麻烦,因为sql语句的where条件不一定,可能多也可能少,占位符需要和参数一一对应。

    解决:Mybatis自动将java对象映射至sql语句,通过statement中的parameterType定义输入参数的类型。

    4、  对结果集解析麻烦,sql变化导致解析代码变化,且解析前需要遍历,如果能将数据库记录封装成pojo对象解析比较方便。

    解决:Mybatis自动将sql执行结果映射至java对象,通过statement中的resultType定义输出结果的类型。

     

    1.2. mybatis与hibernate不同

    Mybatis和hibernate不同,它不完全是一个ORM框架,因为MyBatis需要程序员自己编写Sql语句。mybatis可以通过XML或注解方式灵活配置要运行的sql语句,并将java对象和sql语句映射生成最终执行的sql,最后将sql执行的结果再映射生成java对象。

     

    Mybatis学习门槛低,简单易学,程序员直接编写原生态sql,可严格控制sql执行性能,灵活度高,非常适合对关系数据模型要求不高的软件开发,例如互联网软件、企业运营类软件等,因为这类软件需求变化频繁,一但需求变化要求成果输出迅速。但是灵活的前提是mybatis无法做到数据库无关性,如果需要实现支持多种数据库的软件则需要自定义多套sql映射文件,工作量大。

     

    Hibernate对象/关系映射能力强,数据库无关性好,对于关系模型要求高的软件(例如需求固定的定制化软件)如果用hibernate开发可以节省很多代码,提高效率。但是Hibernate的学习门槛高,要精通门槛更高,而且怎么设计O/R映射,在性能和对象模型之间如何权衡,以及怎样用好Hibernate需要具有很强的经验和能力才行。

    总之,按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构,所以框架只有适合才是最好。 

    2.   Dao开发方法

           使用MyBatis开发Dao,通常有两个方法,即原始Dao开发方法和Mapper动态代理开发方法。

     

    2.1. 需求

    使用MyBatis开发DAO实现以下的功能:

    根据用户id查询一个用户信息

    根据用户名称模糊查询用户信息列表

    添加用户信息

     

    2.2. SqlSession的使用范围

    SqlSession中封装了对数据库的操作,如:查询、插入、更新、删除等。

    SqlSession通过SqlSessionFactory创建。

    SqlSessionFactory是通过SqlSessionFactoryBuilder进行创建。

    2.2.1. SqlSessionFactoryBuilder

    SqlSessionFactoryBuilder用于创建SqlSessionFacoty,SqlSessionFacoty一旦创建完成就不需要SqlSessionFactoryBuilder了,因为SqlSession是通过SqlSessionFactory创建的。所以可以将SqlSessionFactoryBuilder当成一个工具类使用,最佳使用范围是方法范围即方法体内局部变量。

    2.2.2. SqlSessionFactory

           SqlSessionFactory是一个接口,接口中定义了openSession的不同重载方法,SqlSessionFactory的最佳使用范围是整个应用运行期间,一旦创建后可以重复使用,通常以单例模式管理SqlSessionFactory。

    2.2.3. SqlSession

           SqlSession是一个面向用户的接口,sqlSession中定义了数据库操作方法。

           每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能共享使用,它也是线程不安全的。因此最佳的范围是请求或方法范围。绝对不能将SqlSession实例的引用放在一个类的静态字段或实例字段中。

     

     

    1.1. Mapper动态代理方式  

     

    1.1.1. 开发规范

     

           Mapper接口开发方法只需要程序员编写Mapper接口(相当于Dao接口),由Mybatis框架根据接口定义创建接口的动态代理对象,代理对象的方法体同上边Dao接口实现类方法。

     

     

     

    Mapper接口开发需要遵循以下规范:

     

    1、  Mapper.xml文件中的namespace与mapper接口的类路径相同。

     

    2、  Mapper接口方法名和Mapper.xml中定义的每个statement的id相同

     

    3、  Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同

     

    4、  Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

     

     

     

    1.   SqlMapConfig.xml配置文件

    1.1. 配置内容

    SqlMapConfig.xml中配置的内容和顺序如下:

     

    properties(属性)

    settings(全局配置参数)

    typeAliases(类型别名)

    typeHandlers(类型处理器)

    objectFactory(对象工厂)

    plugins(插件)

    environments(环境集合属性对象)

    environment(环境子属性对象)

    transactionManager(事务管理)

    dataSource(数据源)

    mappers(映射器)

     

    1.1. typeAliases(类型别名)

    1.1.1. mybatis支持别名:

    别名

    映射的类型

    _byte

    byte

    _long

    long

    _short

    short

    _int

    int

    _integer

    int

    _double

    double

    _float

    float

    _boolean

    boolean

    string

    String

    byte

    Byte

    long

    Long

    short

    Short

    int

    Integer

    integer

    Integer

    double

    Double

    float

    Float

    boolean

    Boolean

    date

    Date

    decimal

    BigDecimal

    bigdecimal

    BigDecimal

    map

    Map

    1.2自定义别名sqlmapconfig.xml文件中

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <!-- 是用resource属性加载外部配置文件 -->
        <properties resource="db.properties">
            <!-- 在properties内部用property定义属性 -->
            <property name="jdbc.username" value="root123" />
            <property name="jdbc.password" value="root123" />
        </properties>
    
        <typeAliases>
            <!-- 单个别名定义 -->
            <typeAlias alias="user" type="cn.itcast.mybatis.pojo.User" />
            <!-- 批量别名定义,扫描整个包下的类,别名为类名(大小写不敏感) -->
            <package name="cn.itcast.mybatis.pojo" />
            <package name="其它包" />
        </typeAliases>
    
        <!-- 和spring整合后 environments配置将废除 -->
        <environments default="development">
            <environment id="development">
                <!-- 使用jdbc事务管理 -->
                <transactionManager type="JDBC" />
                <!-- 数据库连接池 -->
                <dataSource type="POOLED">
                    <property name="driver" value="${jdbc.driver}" />
                    <property name="url" value="${jdbc.url}" />
                    <property name="username" value="${jdbc.username}" />
                    <property name="password" value="${jdbc.password}" />
                </dataSource>
            </environment>
        </environments>
    
        <!-- 加载映射文件 -->
        <mappers>
            <mapper resource="sqlmap/User.xml" />
            <mapper resource="mapper/UserMapper.xml" />
        </mappers>
    </configuration>

    1.1. mappers(映射器)

    Mapper配置的几种方法:

    1.1.1. <mapper resource=" " />

    使用相对于类路径的资源(现在的使用方式)

    如:<mapper resource="sqlmap/User.xml" />

     

    1.1.2. <mapper class=" " />

    使用mapper接口类路径

    如:<mapper class="cn.itcast.mybatis.mapper.UserMapper"/>

     

    注意:此种方法要求mapper接口名称和mapper映射文件名称相同,且放在同一个目录中。

     

    1.1.3. <package name=""/>

    注册指定包下的所有mapper接口

    如:<package name="cn.itcast.mybatis.mapper"/>

    注意:此种方法要求mapper接口名称和mapper映射文件名称相同,且放在同一个目录中。

     

    转载于:https://www.cnblogs.com/yuyang123/p/9677606.html

    展开全文
  • (一)JDBC的基本概念: 关于JDBC大家应该有很熟悉,JDBC(Java DataBase Connectivity,java数据库连接),用于执行SQL语句的java API ,可以为多种关系数据库提供统一访问。 JDBC的简单使用 JDBC可以做三件事,第一...
  • jdbc封装类 2021.3.27编辑
  • 原生JDBC整合Druid

    2020-08-21 14:44:46
    @ResponseBody @GetMapping("/sql") public String showSql(){ List> maps = jdbcTemplate.queryForList("select * from blog"); return maps.get(0).toString(); } } 使用java建表,建表语句默认文件:schema-*....
  • springboot整合原生JDBC

    2021-10-21 11:00:18
    一、创建一个springboot项目并添加如下模块 二、配置 官方建议使用.yaml后缀的配置文件,所以我们也使用.yaml后缀名的配置文件 创建application.yaml配置... url: jdbc:mysql://localhost:3306/数据库名?us...
  • 原生JDBC操作数据库

    2020-04-10 22:26:22
    原生jdbc实现批量操作 @Component public class JdbcAction{ private static final Logger logger = LoggerFactory.getLogger(JdbcAction.class); // 每500条执行一次 private final int MAX_ADDBATCH_NUM = ...
  • 现在都是使用mybatis来操作数据库,至于如何使用JDBC来操作数据库,基本上忘记的差不多了,特此记录一下 感情深不深 ,都在代码里,废话不多说,直接上代码 import java.sql.Connection; import java.sql....
  • 今天就带大家一起学习一下原生JDBC连接数据库 里面解析结果集说了两种:一种需要导入maven依赖: <dependency> <groupId>commons-dbutils</groupId> <artifactId>commons-dbutils</...
  • 首先,对于大多数项目来说,现在基本上都是用市面上封装好的开源框架,但是我们仍然需要了解JDBC,因为JDBC是基础,所有的开源框架都是基于最原始的JDBC封装加强的,而对于JDBC的使用场景,还是有一席之地的,因...
  • 原生JDBC开发的步骤 三.定义原生JDBCUtils.java工具类 四.DBCP连接池 五.C3P0连接池 六.DBUtils编写语句 一.JDBC 介绍:java语言操作各种数据库的技术 * JDBC由一堆接口和类组成 * 类:DriverManger,用于注册...
  • 原生JDBC工具类封装

    2020-09-03 19:47:21
    无论是mybatis还是hibernate都是只是将JDBC进行了封装,于是乎参考了老师的套路自己也封装了一些功能。...等原生JDBC操作… 上代码: package com.util; import com.alibaba.druid.pool.DruidDataS
  • List list = new ArrayList(); try { // 加载数据库驱动 Class.forName(“com.mysql.jdbc.Driver”); // 通过驱动管理类获取数据库链接 connection = (Connection) DriverManager.getConnection( “jdbc:mysql...
  • private static String jdbcUrl = "jdbc:mysql://192.168.1.6:3306/10bei_portal"; private static String user = "root"; private static String pwd = "123456"; public static Connection getConnection() ...
  • mybatis 执行JDBC SQL语句第一方式 使用mybatis 预留的Connection接口 this.ss 就是 SqlSession 会话 @Test public void s1() throws SQLException { Connection conn = this.ss.getConnection(); 返回Connec.....
  • 原生jdbc复习

    2017-05-15 15:02:25
    public List testQuery(String openid, int page) { Connection con = null; try { //获取一个数据库,连接,实现方式略,可以使用spring生成 con = ConnectionFactory.getInstance().getConnection(Constant...
  • 使用原生jdbc 封装一个简易的Orm 数据库配置类 DbContextOption package jdbc读取数据库; /** * 数据库配置类 * @author QH * */ public class DbContextOption { /** * 连接字符串 */ String ...
  • 使用java原生jdbc完成数据的增删改查

    千次阅读 2016-09-21 15:33:24
    使用html原生表格标签来展示数据 h2 > < table id = "display" border = "1" cellspacing = "0" cellpadding = "3" > table > < div id = "addOrUpate" > div > body > html > ...
  • 原生JDBC 连接数据库

    2021-03-02 17:53:31
    今天项目运用到了从内部连接其他的数据库获取数据源,想了一会还是发现用原生jdbc来实现比较舒服以下是代码 可以直接调用 private ArrayList<Map<Object, Object>> Test() throws Exception { Class...
  • 前几天被一个项目对接要搞死了,搞了好几天,各种方法去试、各种百度去搜、各个门道去问,...原理:运用原生JDBC /** * 查询数据 * @return */ public List<AttThirdIMessagetem> getSelectData( String ip,
  • 一.JDBC(Java Data Base Connectivity,java数据库连接) 是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。 JDBC提供了一种基准,据此可以构建更高级...
  • 自定义 Mybatis 之原生jdbc案例前言一、JDBC规范(掌握四个核心对象)二、JDBC原理三、原生jdbc开发步骤四、原生jdbc案例4.1、建库建表4.2、创建pojo对象4.3、jdbc代码4.4、测试程序4.5、原生jdbc存在的问题 ...
  • 原生JDBC操作

    2018-11-12 15:59:00
    原生JDBC操作结果集 Class.forName(className); Connection con = DriverManager.getConnection(jdbcUrl, username, password); PreparedStatement prepareStatement = con.prepareStatement(sql); if((sql...
  •  经过查hibernate的原代码发现可以利用session来获取preparestatement来执行原生jdbc查询的, 所以函数改为: public List<String> getColumnList(String pvSql){ List<String> lvRet=new ArrayList(); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,303
精华内容 6,521
关键字:

原生jdbclist