JDBC,MyBatis

JDBC(MyBatis的底层原理) 01

1. 什么是JDBC

JDBC(Java DataBase Connectivity) ,Java提供的一种连接关系型数据库,执行SQL语句的api
其实质是一套规范(接口),帮助开发人员快速实现不同关系型数据库的链接.

2. 使用方法

1. 导入jar包 mysql-connector-java.jar
2. 注册驱动
3. 获取连接
4. 获取执行者对象
5. 执行sql语句,接收返回值
6. 关闭资源

Class.forName("com.mysql.jdbc.Driver");

Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/db2", "root", "password");

Statement stat = con.createStatement();
String sql = "SELECT * FROM user";
ResultSet rs = stat.executeQuery(sql);

con.close();
stat.close();
rs.close();

3.使用方法的进化,提取工具类和properties文件

JDBC工具类:

public class JDBCUtils {
    //1.私有构造方法
    private JDBCUtils(){};

    //2.声明配置信息变量
    private static String driverClass;
    private static String url;
    private static String username;
    private static String password;
    private static Connection con;

    //3.静态代码块中实现加载配置文件和注册驱动
    static{
        try{
            //通过类加载器返回配置文件的字节流
            InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("config.properties");

            //创建Properties集合，加载流对象的信息
            Properties prop = new Properties();
            prop.load(is);

            //获取信息为变量赋值
            driverClass = prop.getProperty("driverClass");
            url = prop.getProperty("url");
            username = prop.getProperty("username");
            password = prop.getProperty("password");

            //注册驱动
            Class.forName(driverClass);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //4.获取数据库连接的方法
    public static Connection getConnection() {
        try {
            con = DriverManager.getConnection(url,username,password);
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return con;
    }
//5.释放资源的方法
    public static void close(Connection con, Statement stat, ResultSet rs) {
        if(con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(stat != null) {
            try {
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

JDBC 02

4.执行对象的进化,从creatStatement进化为prepareStatement

prepareStatement为预编译语句,有效提高效率,并防止sql注入

		//1.获取连接
        conn = JDBCUtils.getConnection();
        //2.创建操作SQL对象
        String sql = "SELECT * FROM user WHERE loginname=? AND password=?";
        pstm = conn.prepareStatement(sql);
        //3.设置参数
        pstm.setString(1,loginName);
        pstm.setString(2,password);
        System.out.println(sql);
        //4.执行sql语句，获取结果集
        rs = pstm.executeQuery();

5.获取连接的进化,连接池的应用(了解即可)

使用C3P0,Druid

/*
    使用C3P0连接池
    1.导入jar包
    2.导入配置文件到src目录下
    3.创建c3p0连接池对象
    4.获取数据库连接进行使用
 */
public class C3P0Demo {
    public static void main(String[] args) throws Exception{
        //创建c3p0连接池对象
        DataSource dataSource = new ComboPooledDataSource();

        //获取数据库连接进行使用
        Connection con = dataSource.getConnection();

        //查询全部学生信息
        String sql = "SELECT * FROM student";
        PreparedStatement pst = con.prepareStatement(sql);
        ResultSet rs = pst.executeQuery();
		//处理数据
        while(rs.next()) {
            System.out.println(rs.getInt("sid") + "\t" + rs.getString("name") + "\t" + rs.getInt("age") + "\t" + rs.getDate("birthday"));
        }

        //释放资源
        rs.close();
        pst.close();
        con.close();    // 将连接对象归还池中
        }
     }

/*
    Druid连接池
    1.导入jar包
    2.编写配置文件，放在src目录下
    3.通过Properties集合加载配置文件
    4.通过Druid连接池工厂类获取数据库连接池对象
    5.获取数据库连接，进行使用
 */
public class DruidDemo1 {
    public static void main(String[] args) throws Exception{
        //通过Properties集合加载配置文件
        InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
        Properties prop = new Properties();
        prop.load(is);

        //通过Druid连接池工厂类获取数据库连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        //获取数据库连接，进行使用
        Connection con = dataSource.getConnection();

        //查询全部学生信息
        String sql = "SELECT * FROM student";
        PreparedStatement pst = con.prepareStatement(sql);
        ResultSet rs = pst.executeQuery();

        while(rs.next()) {
            System.out.println(rs.getInt("sid") + "\t" + rs.getString("name") + "\t" + rs.getInt("age") + "\t" + rs.getDate("birthday"));
        }

        //释放资源
        rs.close();
        pst.close();
        con.close();    // 将连接对象归还池中
    }
}

Mybatis 01

1. 什么是Mybatis

Mybatis是一个基于java持久层的框架,内部封装了JDBC,使开发者专注于sql语句,而非连接的创建和销毁等.

MyBatis通过XML或注解的方式配置statement,并通过java对象和statement的动态sql灵活的编写代码.

MyBatis执行sql语句并将返回值映射成java对象,采用ORM(Object Relational Mapping,对象关系映射)思想解决了实体和数据库映射的问题

2. MyBatis的适用方法

1. 添加jar包
2. 创建数据库数据
3. Java中编写对应结果的bean类
4. 编写核心配置文件 eg:MyBatisConfig.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>
<environments default="mysql">
<environment id="mysql">
    <transactionManager type="JDBC"></transactionManager>
    <dataSource type="POOLED">
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/db1"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </dataSource>
</environment>

</environments>
	<!--映射文件的标签-->
    <mappers>
        <mapper resource="com/itheima/mapper/StudentMapper.xml"/>
    </mappers>
</configuration>

6. 编写映射文件 eg:StudentMapper.xml

<?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="StudentMapper">
    <select id="selectAll" resultType="com.itheima.bean.Student">
        select * from student
    </select>

</mapper>

7. 测试代码

/*
    控制层测试类
 */
public class StudentTest01 {
    @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件(这里用的是MyBatis特有的加载资源工具类)
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        //加载配置文件的另一种方法
 		//InputStream is = StudentTest01.class.getClassLoader().getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过SqlSession工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //openSession()方法中添加boolean值表示是否自动提交,默认手动提交.

        //4.执行映射配置文件中的sql语句，并接收结果
        List<Student> list = sqlSession.selectList("StudentMapper.selectAll");

        //5.处理结果
        for (Student stu : list) {
            System.out.println(stu);
        }

        //6.释放资源
        sqlSession.close();
        is.close();
    }
}

重点代码解析
SqlSession会话对象:org.apache.ibatis.session.SqlSession：构建者对象接口。用于执行 SQL、管理事务、接口代理。

3.MyBatis使用升级,核心配置文件的简化(起别名)

：为指定包下所有类起别名的子标签。(别名就是类名,首字母小写)

<!--起别名-->
    <typeAliases>
        <!--
        <typeAlias type="com.itheima.bean.Student" alias="student"/>
        -->
        <package name="com.itheima.bean"/>
    </typeAliase>    

Mybatis 02

1. MyBatis使用升级,接口代理方式实现Dao

Mapper接口开发方式:编写Mapper接口(相当于Dao接口),由MyBatis框架根据接口的定义来创建接口的动态代理对象,代理对象取代了Mapper接口的实现类(代理对象的方法体跟Dao接口的方法体相同).

1.1 代理开发方式

使用代理开发后,持久层只需要有一个mapper,Service层的实现类不需要创建持久层的对象,直接使用接口代理完成

/*
    业务层实现类
 */
public class StudentServiceImpl implements StudentService {
	
    @Override
    public List<Student> selectAll() {
        // 获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();

        // 获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);   
        // StudentMapper mapper = new StudentMapperImpl();

        // 调用实现类对象中的方法来完成操作
        List<Student> list = mapper.selectAll();

        // 释放资源
        sqlSession.close();

        // 返回结果
        return list;
    }

Mapper接口开发的规范

1. Mapper.xml文件中的naemspace与mapper接口的全限定名相同.
   记忆方法:
   ①Mapper.xml是mapper接口的配置文件,所以namespace是mapper的全类名.
   ②getMapper接口代理获得了mapper接口的实现类对象,调用接口的方法时获得方法名,有了全类名+方法名,要找到对应的mapper.xml文件中的sql语句,就要求xml配置文件的namespace与mapper接口的全类名相同,xml的中的id(如<select id = “selectAll”…>)与方法名的id相同,参数方然也要相同
   2)Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
   记忆方法:同1)②
   3)Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql的parameterType的类型相同
   4)Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

1.2 @Param注解

当statement的形参(定义方法时的参数)有多个时,使用注解在参数上,就能为他们自定义名字.

public abstract List<Student> selectByNameOrAge(@Param("p1") String name , @Param("p2") Integer age);

在xml中的使用

<select id="selectByNameOrAge" resultType="student" >
  select * from student WHERE name = #{p1} OR age = #{p2}
</select>

1.3 动态SQL

动态的修改sql语句,如姓名不为空时可以根据姓名查询.

<!--if标签-->
<select id="selectCondition" resultType="student" parameterType="student">
        select * from student
        <where>
            <if test="id != null">and id = #{id}</if>
            <if test="name != null and name != '' "> and name = #{name}</if>
            <if test="age != null">and age = #{age}</if>
        </where>

    </select>

注意
①在动态sql中where标签会识别出and关键字,如果不需要会去掉,所以在写所有where条件时最好都加上and.
②判断字符串时要判null判空串,中间用and分隔.

<!--foreach标签-->
<select id="selectByIds" resultType="student" parameterType="list">
        select * from student
        <where>
            <foreach collection="list" open="id in (" close=")" item="id" separator=",">
                #{id}
            </foreach>

        </where>
</select>

<!--抽取sql语句-->
<sql id="select">select * from student</sql>
    
<select id="selectAll" resultType="student">
    <include refid="select"/>
</select>

1.4 Mybatis多表操作

一对一:

<mapper namespace="com.itheima.table01.OneToOneMapper">
    <!--配置字段和实体对象属性的映射关系-->
    <resultMap id="oneToOne" type="card">
        <id column="cid" property="id"/>
        <result column="number" property="number"/>

        <association property="p" javaType="person">
            <id column="pid" property="id"/>
            <result column="name" property="name"/>
        </association>
    </resultMap>
<select id="selectAll" resultMap="oneToOne">
    SELECT c.id cid,c.number,p.id pid,p.`NAME` FROM card c ,person p WHERE c.pid = p.id
</select>
    <!--
            association：配置被包含对象的映射关系
            property：被包含对象的变量名
            javaType：被包含对象的数据类型
        -->
</mapper>

一对多:

<mapper namespace="com.itheima.table02.OneToManyMapper">
        
<resultMap id="oneToMany" type="classes">
        <result column="cname" property="name"/>
        <collection property="students" ofType="student">
                <result column="name" property="name"/>
                <result column="age" property="age"/>
        </collection>
</resultMap>
        <select id="selectAll" resultMap="oneToMany">
        SELECT s.`NAME`,s.age,c.`NAME` cname FROM student s ,classes c WHERE s.cid = c.id;
        </select>
        <!--
            collection：配置被包含的集合对象映射关系
            property：被包含对象的变量名
            ofType：被包含对象的实际数据类型
        -->
</mapper>

多对多就是一对多.

1.5MyBatis注解开发

用注解的方式代替mapper配置文件.
优点:操作简单,开发效率高.
缺点:不适合复杂的sql语句,不便维护
@Insert：实现新增

@Update：实现更新

@Delete：实现删除

@Select：实现查询

@Result：实现结果集封装

@Results：可以与@Result 一起使用，封装多个结果集

@One：实现一对一结果集封装

@Many：实现一对多结果集封装

@Options(useGeneratedKeys = true,keyColumn = “id”, keyProperty = “id”)返回主键自增