MyBatis-连接数据库001

六个橙_YU

已于 2023-03-16 11:30:26 修改

阅读量480

点赞数

分类专栏： mybatis 文章标签： mybatis java maven Powered by 金山文档

于 2023-02-21 16:41:16 首次发布

本文链接：https://blog.csdn.net/qq_55860753/article/details/129122365

版权

mybatis 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

创建Maven文件，下载配置，修改maven文件里的下载路径，改成阿里云的

注意，要在mirrors里面

在pom.xml文件中配置坐标,选择自己修改的settings.xml文件位置

驱动加载，刷新

<dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
    </dependencies>

探究已映射的 SQL 语句

注意：resources文件里面的包要一个个安装，不能com.cyj.dao创建，这只是一个文件，不然在SqlMapConfig配置的时候找不到文件的地址（可以com/cyj/dao来实现）

com.cyj.dao--UserDao接口

public interface UserDao {
    List<User> findAll();
}

com.cyj.domain--User类

注意：这里的字段要与数据库中的字段名对应，属性名必须一样

package com.cyj.domain;

public class User {
    private Integer id;
    private String name;
    private Integer sal;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getSal() {
        return sal;
    }

    public void setSal(Integer sal) {
        this.sal = sal;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sal='" + sal + '\'' +
                '}';
    }
}

在resources目录下com.cyj.dao创建，UseDao.xml文件配置

id=接口里面的方法

resultType=实体类

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cyj.dao.UserDao">
<!--   这里用.        -->
<!--    namespace:寻找命名空间映射的地址-->
<!--    id:映射接口中对应的方法名称-->
<!--    resultType:寻找结果集的user对象-->
    <select id="findAll" resultType="com.cyj.domain.User">
        select * from user
    </select>
</mapper>

5.在resources目录下创建SqlMapConfig.xml文件

这个文件用于UserDao.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>
    <!-- 配置 mybatis 的环境 -->
    <environments default="mysql">
        <!-- 配置 mysql 的环境 -->
        <environment id="mysql">
            <!-- 配置事务的类型 -->
            <transactionManager type="JDBC"/>
            <!-- 配置连接数据库的信息：用的是数据源(连接池) -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 告知 mybatis 映射配置的位置 -->
    <mappers>
<!--        mapper:加载UserDao.xml文件的-->
        <mapper resource="com/cyj/dao/UserDao.xml"/>
    </mappers>
</configuration>

6.测试连接数据库，用到工厂设计模式（总共有23种），这里我还不清楚

session用于数据库交互的。

1>Resources获取操作数据库的xml文件（董事长获取资源，将获取的资源给总经理）

2>获取文件之后，创建一个工厂创建者，建造一个关于数据库的session会话（总经理拿到资源后给部门经理）

3>sqlSession打开会话，返回一个对象A（部门经理将资源打开共享给部门主管）

4>A对象通过接口去获取代理对象，代理对象去操作响应的crud,不让老板干事，地下员工干事（部门主管找部门员工去找接口干活）

import com.cyj.dao.UserDao;
import com.cyj.domain.User;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class Test {
    public static void main(String[] args) throws IOException {
        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建 SqlSessionFactory 的构建者对象,使用构建者创建工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //4.使用 SqlSession 创建 dao 接口的代理对象
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        //5.使用代理对象执行查询所有方法
        List<User> userDao = mapper.findAll();

        for(User user:userDao){
            System.out.println(user);
        }
        //6.释放资源
        sqlSession.close();
        in.close();
    }
}

日志文件导入，要下载之后maven才会起作用。

直接导入在resources文件下，注意target文件删除

运行成功后，日志会记录相关信息

将test中的main方法进行改造一哈，因为，session会话要多次使用

@Before--@test--@After,依次先后执行

package com.cyj.test;

import com.cyj.dao.UserDao;
import com.cyj.domain.User;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class Test {
    private InputStream in;
    private SqlSessionFactory sqlSessionFactory;
    private SqlSession sqlSession;
    private UserDao mapper;

    @Before //在测试方法之前进行
    public void init() throws IOException {
        //1.读取配置文件
        in=Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建 SqlSessionFactory 的构建者对象,使用构建者创建工厂对象
        sqlSessionFactory=new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = sqlSessionFactory.openSession();
        //4.使用 SqlSession 创建 dao 接口的代理对象
         mapper = sqlSession.getMapper(UserDao.class);
    }

    @Test
    public void findAll(){
        //5.使用代理对象执行查询所有方法
        List<User> userDao = mapper.findAll();

        for (User user : userDao) {
            System.out.println(user);
        }
    }

    @After//在单元测试方法执行完之后进行
    public void destroy() throws IOException {
        //6.释放资源
        sqlSession.close();
        in.close();
    }
}

6.1小插曲，如何解决xml文件代码没色和背景色消去问题

链接1：https://blog.csdn.net/weixin_51757064/article/details/122471303

改了后不行就第二个

链接2：https://blog.csdn.net/daban2008/article/details/127334753

实现添加操作

-- 【注】：mybatis里面严格遵循一个坑占一个，数据库中设置了自增长不能加null,后面#{}

--【注】：xml文件中，不能加注解

下面这个是错的，不然搞~人.

--添加出了点问题

什么问题尼，就是sql语句中字体没提示，然后按Alt+Enter后Language injection settings里面的编码格式要是sql为不是MySQL。

接口层写方法

    --UserDao接口
    int addUser(User user);

    --resources下的UserDao.xml文件
<insert id="addUser" parameterType="com.cyj.domain.User">
        insert into user(null,name, sal) values(#{},#{name}, #{sal})
        -- 这是错的
</insert>

    @org.junit.Test //添加
    public void insertInto(){
        User user = new User(null,"程",2000);
        int i = userDaoMapper.addUser(user);
        System.out.println(i);//如果添加有返回值，那么加入成功后返回1，失败返回0;
    }

删除，修改，通过ID查找，模糊查询，实现过程相同

User类

package com.cyj.domain;

public class User {
    private Integer id;
    private String name;
    private Integer sal;

    public User(Integer id, String name, Integer sal) {
        this.id = id;
        this.name = name;
        this.sal = sal;
    }
//如果写了带参数的构造方法，那么默认的构造方法就取消了，要重写
    public User() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getSal() {
        return sal;
    }

    public void setSal(Integer sal) {
        this.sal = sal;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sal='" + sal + '\'' +
                '}';
    }
}

接口UserDao

public interface UserDao {
    //1.查找所有
    List<User> findAll();
    //2.添加
    int addUser(User user);
    //3.删除
    int deleteUser(int id);
    //4.修改
    int updateUser(User id);
    //5.通过id查找
    User findById(int id);
    //6.模糊查寻
    List<User> findSameSurname(String str);

    //7.查询多少列
    int findList();

    //8.模糊查询多条判断语句
    List<User> findByUserLike(User user);

    //9.id范围查询
    List<User> findByIds(QueryVo vo);

    //10.多表查询
    List<Account> findAll_A_U();
}

9>插曲.创建QueryVo类

package com.cyj.domain;

import java.util.List;

public class QueryVo {
    //通过所有的id去获取用户用foreach实现
    private static List<Integer> ids;

    public List<Integer> getIds() {
        return ids;
    }

    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }
}

10>.插曲。在account中设置user,这时数据库中的account表（aid为主键）要设置外键uid外键（连user-id），user中id为主键

package com.cyj.domain;

public class Account {
    private int aid;
    private String uid;
    private String type;

    private User user;

    public int getAid() {
        return aid;
    }

    public void setAid(int aid) {
        this.aid = aid;
    }

    public String getUid() {
        return uid;
    }

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

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    @Override
    public String toString() {
        return "Account{" +
                "aid=" + aid +
                ", uid='" + uid + '\'' +
                ", type='" + type + '\'' +
                ", user=" + user +
                '}';
    }
}

reources下的UsesDao.xml配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cyj.dao.UserDao">
    <!--    namespace:寻找命名空间映射的地址,接口的地址-->
    <!--    id:映射接口中对应的方法名称-->
    <!--    resultType:寻找结果集的user对象-->
    <!--    1.-->
    <select id="findAll" resultType="com.cyj.domain.User">
        select * from user
    </select>

    <!--    添加-->
    <!--    1.#{name}:用于占位的（占位符），没有根河含义-->
    <!--    2.parameterType：对应方法中的参数类型-->
    <!--    3.如果是常用的基本类型，就直接int,String 就可以，也可以java.lang.String-->
    <!--    在sql下加注解-->
    <!--    2.-->
    <insert id="addUser" parameterType="com.cyj.domain.User">
        insert into user(name, sal) values(#{name}, #{sal})
    </insert>

    <!--    删除-->
    <!--    3.-->
    <delete id="deleteUser" parameterType="int">
        delete from user where id=#{id}
    </delete>

    <!--    5.-->
    <select id="findById" resultType="com.cyj.domain.User" parameterType="int">
        select * from user where id=#{id};
    </select>

    <!--    修改-->
    <!--  展位符是#不是$，不然Unknown column 'cyj' in 'field list'  -->
    <!--    4.-->
    <update id="updateUser" parameterType="com.cyj.domain.User">
        update user set name=#{name},sal=#{sal} where id=#{id};
    </update>

    <!--  模糊查询-->
    <!--    6.-->
    <select id="findSameSurname" parameterType="String" resultType="com.cyj.domain.User">
        select * from user where name like #{surName}
    </select>


    <!--    查找列数-->
    <!--    7.-->
    <select id="findList" resultType="int">
        select count(*)
        from user
    </select>


    <!--    8.-->
    <!--    把要用到的一样语句用sql写用include调用.-->
    <sql id="defaultSql">
        select *
        from user
    </sql>

    <!--多条件模糊查询:根据用户信息进行查询,where自带1=1-->
    <!-- select  *  from user  where username like #{username} and address like #{address}-->
    <select id="findByUserLike" resultType="com.cyj.domain.User" parameterType="com.cyj.domain.User">
        <include refid="defaultSql"></include>
        <where>
            <if test="name!=null and name!=''">
                and name like
                #{name}
            </if>
        </where>
    </select>

    <!--    foreach实现查询语句-->
<!--    open后面拼接的in后面要输入值，#{uid}进行占位-->
    <!--    9.-->
    <select id="findByIds" resultType="com.cyj.domain.User" parameterType="Integer">
        <include refid="defaultSql"></include>
        <where>
            <if test="ids!=null and ids.size()>0">
                <foreach collection="ids" open="id in(" close=")" item="uid" separator=",">
                    #{uid}
                </foreach>
            </if>
        </where>
    </select>


<!--  resultMap重新定义名字 id：自己定义的名称 type：自己对应的.Java类中的名字  column是数据库中的名字 property是.java类中的属性-->
<!--   在sqlMapConfig.xml中进行配置  typeAliases 设置了这个，后面IUserDao里面的type所有的就可以直接写实体类-->
<!--    10.如果.java类中的的属性与数据库中的属性不一样，则用resultMap进行匹配-->
    <resultMap id="accountMap" type="account">
        <id column="aid" property="aid"></id>
        <result column="uid" property="uid"></result>
        <result column="type" property="type"></result>

        <association property="user" javaType="User">
            <id column="id" property="id"></id>
            <result column="name" property="name"></result>
            <result column="sal" property="sal"></result>
        </association>
    </resultMap>

<!--    多表查询 后面的resultType对应的是account中的account类，因为在sql中写了typeAliases-->
    <select id="findAll_A_U" resultMap="accountMap">
        select u.*,a.aid,a.type,a.uid from user u, account a where u.id=a.uid
    </select>



</mapper>

Test测试

public class Test {
    private InputStream in;
    private SqlSessionFactory sqlSessionFactory;
    private SqlSession sqlSession;
    private UserDao userDaoMapper;

    @Before //在测试方法之前进行
    public void init() throws IOException {
        //1.读取配置文件
        in=Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建 SqlSessionFactory 的构建者对象,使用构建者创建工厂对象
        sqlSessionFactory=new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = sqlSessionFactory.openSession();
        //4.使用 SqlSession 创建 dao 接口的代理对象
         userDaoMapper = sqlSession.getMapper(UserDao.class);
    }

    @org.junit.Test  //查找
    public void findAll(){
        //5.使用代理对象执行查询所有方法
        List<User> userDao = userDaoMapper.findAll();
        for (User user : userDao) {
            System.out.println(user);
        }
    }

    @org.junit.Test //添加
    public void insertInto(){
        User user = new User(null,"程",2000);
        int i = userDaoMapper.addUser(user);
        System.out.println(i);//如果添加有返回值，那么加入成功后返回1，失败返回0;
    }

//    @org.junit.Test
//    public void findById(){
//        User byIdUser = userDaoMapper.findById(5);
//    }

    @org.junit.Test
    public void delete(){
        int i = userDaoMapper.deleteUser(5);
        System.out.println(i);
    }

    @org.junit.Test
    public void updateUser(){
        User user = userDaoMapper.findById(5);
        user.setName("cyj");
        userDaoMapper.updateUser(user);
    }

    @org.junit.Test
    public void findAllSurname(){//模糊查询，返回集合，注意输入格式
        List<User> sameSurname = userDaoMapper.findSameSurname("c%");
        for(User u:sameSurname){
            System.out.println(u);
        }
    }

    //7.
        @org.junit.Test
    public void findNumber(){
        int list = userDaoMapper.findList();
        System.out.println(list);
    }

//    8.多条件模糊查询
    @org.junit.Test
    public void findByAllLike(){
        User user = new User();
        user.setName("%c%");
        List<User> UserLikes = userDaoMapper.findByUserLike(user);
        for(User uu:UserLikes){
            System.out.println(uu+" name");
        }
    }

  // 9.
    //范围查询
    //如果配置文件有一个地方错了，就不能运行
    @org.junit.Test
    public void findByIds(){
        QueryVo queryVo = new QueryVo();
        ArrayList<Integer> ids = new ArrayList<>();
        ids.add(6);
        ids.add(7);
        System.out.println(ids.toString());
        queryVo.setIds(ids);

        List<User> users = userDaoMapper.findByIds(queryVo);
        for(User user:users){
            System.out.println(user);
        }
    }
    
    
    //10.连表查询
    @org.junit.Test
    public void findAll_A_U(){
        List<Account> all_a_u = userDaoMapper.findAll_A_U();
        for(Account account:all_a_u){
            System.out.println(account);
        }
    }

    @After//在单元测试方法执行完之后进行
    public void destroy() throws IOException {
        //6.释放资源
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }
}

resources下的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>


    <!--   typeAliases 设置了这个，后面IUserDao里面的type所有的就可以直接写实体类-->
    <typeAliases>
        <package name="com.cyj.domain"/>
    </typeAliases>



    <!-- 配置 mybatis 的环境 -->
    <environments default="mysql">
        <!-- 配置 mysql 的环境 -->
        <environment id="mysql">
            <!-- 配置事务的类型 -->
            <transactionManager type="JDBC"/>
            <!-- 配置连接数据库的信息：用的是数据源(连接池) -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="woaini1219"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 告知 mybatis 映射配置的位置 -->
    <mappers>
<!--        mapper:加载UserDao.xml文件的-->
        <mapper resource="com/cyj/dao/UserDao.xml"/>
    </mappers>
</configuration>