框架(mybatis单表增，删，改，查)

1.什么是框架

框架(Framework)是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法
另一种定义认为，框架是可被应用开发者定制的应用骨架。
前者是从应用方面而后者是从目的方面给出的定义。简而言之，框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。

2.框架要解决的问题

框架要解决的最重要的一个问题是技术整合的问题，在 J2EE 的 框架中，有着各种各样的技术，不同的软件企业需要从 J2EE 中选择不同的技术工这就使得软件企业最终的应用依赖于这些技术，技术自身的复杂性和技术的风险性将会直接对应用造成冲击。而应用是软件企业的核心，是竞争力的关键所在，因此应该将应用自身的设计和具体的实现技术解偶。
这样，软件企业的研发将集中在应用的设计上，而不是具体的技术实现，技术实现是应用的底层支撑，它不应该直接对应用产生影响。
框架一般处在低层应用平台(如J2EE)和高层业务逻辑之间的中间层。

3.  软件开发的分层重要性

框架的重要性在于它实现了部分功能，并且能够很好的将低层应用平台和高层业务逻辑进行了缓和，为了实现 软件工程中的“高内聚、低耦合”。把问题划分开来各个解决，易于控制，易于延展，易于分配资源。我们常见的MVC软件设计思想就是很好的分层思想。

4.什么是MyBatis?
MyBatis是一个开源、轻量级的数据持久化框架，是JDBC和Hibernate的替代方案。
MyBatis前身为IBatis，2002年由 Clinton Begin发布。2010年从Apache 迁移到Google，并改名为 MyBatis，2013年又迁移到了Github.

•mybatis是一个优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement 等繁杂的过程。
•mybatis 通过 xml 或注解的方式将要执行的各种 statement 配置起来，并通过java 对象和 statement 中 sql的动态参数进行映射生成最终执行的sql语句，最后由mybatis 框架执行sql并将结果映射为java对象并返回。
•采用ORM思想解决了实体和数据库映射的问题，对jdbc进行了封装，屏蔽了jdbc api底层访问细节，使我们不用与jdbc apl打交道，就可以完成对数据库的持久化操作。
•MyBatis支持定制化 SQL、存储过程以及高级映射，可以在实体类和SQL语句之间建立映射关系，是一种半自动化的ORM实现。 I 

优点

1.mybatis 内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接，创建 statement 等繁杂的过程。
2.mybatis 通过 xml 或注解的方式将要执行的各种 statement 配置起来，并通过 java 对象和statement中sql 的动态参数进行映射生成最终执行的sql 语句，最后由 mybatis 框架执行 sql并将结果映射为java对象并返回。
3.采用ORM思想解决了实体和数据库映射的问题，对jdbc进行了封装，屏蔽了jdbc api底层访问细节，使我们不用与jdbc api打交道，就可以完成对数据库的持久化操作。

mybatis入门案例

1. 创建测试的数据库

#判断存在即删除数据库
drop database if exists mydb;
#创建数据库
create database mydb;
#使用数据库
use mydb;
#创建表
create table t_user
(
uid int primary key auto_increment,
username varchar(20),
password varchar(20),
phone varchar(11),
address varchar(50)
);
insert into t_user(username,password,phone,address) values('张
三','666','18965423548','南阳');
insert into t_user(username,password,phone,address) values('李
四','333','18754263548','许昌');
insert into t_user(username,password,phone,address) values('小
美','123','18565234759','信阳');
select * from t_user;

2. 创建一个 Java 项目并导入 mybatis 框架的 jar 包

在项目中创建一个 lib 文件夹放入 mybatis 框架的 jar 包，并导入项目中。

 3.创建跟表对应的实体类

在src中创建com.chen.bean包，然后创建User实体类。

package com.zhy.bean;

public class User {
    private Integer uid;
    private String username;
    private String password;
    private String phone;
    private String address;

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    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 String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }


    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", phone='" + phone + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

4. 创建针对表操作的接口类

在 src 中创建 com.chen.dao 包，然后创建 UserDao 的接口，然后在接口中定义针对数据库的增删

改查等操作。

public interface UserDao {

/**

* 查询所有用户信息

* @return

*/

//全查
List<User> selectAll();
//单差
 User findbbyid(int uid);
//添加
int insert(User user);
//删除
int del(int uid);
//修改
int update(User user);

}

5.在接口的包中创建对应的mapper映射配置文件。

在dao接口的同目录下创建跟接口名字一样的配置文件。  

 6.在src目录中创建mybatis框架的核心配置文件。

在 src 中创建一个文件，命名为 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>
<!--配置环境信息===就是配置连接数据库的参数
default：指定配置的环境信息的id，表示默认连接该环境
-->
<environments default="mysql">
<environment id="mysql">
<!--配置事务的处理方式：模式使用JDBC的事务处理-->
<transactionManager type="jdbc"></transactionManager>
<!--数据源的默认type设置为pooled，表示使用连接池-->
<dataSource type="pooled">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mydb"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</dataSource>
</environment>
<environment id="oracle">
<transactionManager type=""></transactionManager>
<dataSource type=""></dataSource>
</environment>
</environments>
<!--加载mapper配置文件-->
<mappers>
<mapper class="com.chen.dao.UserDao" />
</mappers>
</configuration>

7. 在测试类中进行测试

使用 mybatis 框架需要按照框架的步骤进行

package com.zhy.test;

import com.zhy.bean.User;
import com.zhy.dao.UserDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class UserTest {
    InputStream stream=null;
    SqlSessionFactoryBuilder builder=null;
    SqlSessionFactory factory=null;
    SqlSession sqlSession=null;
    UserDao userDao=null;

    @Before
    public void  into() throws IOException {
        //1.加载核心配置文件的字节输入流
        stream = Resources.getResourceAsStream("mybatis.xml");
        //2.创建的构造SqlSessionFactoryBuilder对象--框架使用的是构建者模式
        builder=new SqlSessionFactoryBuilder();
        //3.通过构建对象加载配置文件的输入流获取SqlSessionFactory
        factory=builder.build(stream);
        //4.通过工厂对象获取SqlSession对象----执行JDBC操作的
        sqlSession=factory.openSession();
        //5.通过SqlSession对象获取接口对应的代理对象
        userDao=sqlSession.getMapper(UserDao.class);

    }

    @Test
    public void select(){
        //6.通过代理对象执行查询方法
        List<User> userList = userDao.selectAll();
        //7.遍历集合
        for (User user : userList) {
            System.out.println(user);
        }
    }

    @Test

    public void add() throws IOException {
        //6.通过代理对象执行查询方法
        User user=new User();
        user.setUsername("555");
        user.setPassword("555");
        user.setPhone("5555");
        user.setAddress("55555");
        int add = userDao.insert(user);

        //7.遍历集合
        if (add>0){
            System.out.println("添加成功");
        }else {
            System.out.println("添加失败");
        }

        //sqlSession.commit();
    }


    @Test
    public void delete() throws IOException {

        //6.通过代理对象执行查询方法
        int add = userDao.del(11);
        //7.判断
        if (add>0){
            System.out.println("删除成功");
        }else {
            System.out.println("删除失败");
        }
        //sqlSession.commit();
    }

    @Test
    public void findbyid(){
        User user = userDao.findbbyid(1);
        System.out.println(user);
    }


    @Test
    public void update(){
        User olduser = userDao.findbbyid(1);
        System.out.println("修改前"+olduser);

        olduser.setUsername("张三");
        olduser.setAddress("郑州");
       userDao.update(olduser);
       User nuser= userDao.findbbyid(1);
        System.out.println("修改后"+nuser);
    }

    @After
    public void distroy() throws IOException {
        sqlSession.commit();
        sqlSession.close();
        stream.close();
    }

}

运行结果如下

log4j:WARN No appenders could be found for logger (org.apache.ibatis.logging.LogFactory).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
User{uid=1, username='张三', password='666', phone='18965423548', address='南阳'}
User{uid=2, username='李四', password='333', phone='18765426548', address='许昌'}
User{uid=3, username='小美', password='123', phone='18565234759', address='信阳'}
User{uid=4, username='小红', password='333', phone='1234567898', address='郑州'}
User{uid=5, username='小明', password='44444', phone='1234567898', address='重庆'}
User{uid=6, username='667', password='096', phone='13525100739', address='开封'}

 核心配置文件包括的部分

1.属性（properties）
我们可以通过使用properties属性来实现引用配置文件

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置 。[jdbc.properties]

 

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mydb
jdbc.user=root
jdbc.password=root

 

2.类型别名（typeAliases）
​ 注意：它仅用于 XML 配置。类型别名可为 Java 类型设置一个缩写名字。降低冗余的全限定类名

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 JavaBean：
每一个在包 中的 JavaBean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名

<typeAliases>
        <package name="com.zhy.bean"/>
    </typeAliases>

3.什么是log4j：

Log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
我们也可以控制每一条日志的输出格式
通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程
最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

<settings>
        <setting name="logImpl" value="log4j"/>
    </settings>
    

4.数据库连接信息

<environments default="mysql">
        <environment id="mysql">
            <transactionManager type="jdbc"></transactionManager>
            <dataSource type="pooled">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.user}"/>
                <property name="password" value="${jdbc.password}"/>
                
            </dataSource>
        </environment>
    </environments>
    

5.插件配置

<dataSource type="pooled">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.user}"/>
                <property name="password" value="${jdbc.password}"/>
                
            </dataSource>

6.映射器配置

 <mappers>
        <package name="com.zhy.dao"/>
    </mappers>

生命周期

生命周期和作用域是至关重要的，因为错误的使用会导致非常严重的并发问题

• SqlSessionFactoryBuilder：
• 一旦创建了 SqlSessionFactory，就不再需要它了
• 局部变量
• SqlSessionFactory：
• 说白了可以想象为：数据库连接池
• 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
• 最佳作用域是应用作用域
• 最简单的就是使用单例模式或者静态单例模式。
• SqlSession：
• 连接到连接池的一个请求
• SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域
• 用完之后赶紧关闭，否则占用资源