_淡若清风づ

JAVA MyBatis框架(超详细教程)

MyBatis 框架

一、MyBatis 框架概述：

学习MyBatis必须先学懂JDBC、MySQL、Maven
复习跳转：JDBC

1.是什么？

MyBatis是一款优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。
➢MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。
➢MyBatis 可以使用简单的XML或注解来配置和映射原生类型、接口和Java的POJO (Plain Old JavaObjects，普通老式Java对象）为数据库中的记录。
➢MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation迁移到了google code，并且改名为MyBatis。
➢2013年11月迁移到Github。

2.应用的优势？

核心作用：帮助程序员将数据存入到数据库中
方便(为了更好的偷懒)
传统的JDBC代码太复杂了，简化，框架，自动化
不用MyBatis也可以，只是更复杂，学了更容易上手。

优点(特性)：
➢简单易学：本身就很小且简单。
➢灵活：不会对应用程序或数据库设的现有设计有任何影响。
➢解除了sql和代码的耦合或者说分离，提高了可维护性。
➢提供映射标签，支持对象与数据库的orm字段关系映射。
➢提供对象关系映射标签，支持对象关系组建维护。
➢提供xml标签，支持编写动态sql。

3.如何获得mybatis？

Github链接:https://github.com/mybatis/mybatis-3

maven仓库

maven仓库：

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
</dependency>

4.什么是持久层？

数据持久化

➢持久化就是将程序的数据在持久状态和瞬时状态转化的过程
➢ 内存：断电即失
➢数据库（Jdbc）,io文件持久化。
➢持久化生活案例：冷藏、罐头、真空压缩

为什么要持久化？

有一些数据或对象，不能让他丢掉。
在生活中懂电脑的同学都知道内存很贵。

5.什么是持久层？

Dao层、Service层、Controller层

完成持久化工作的代码块
层界限模块化很明显

小结：

为什么要学它？（因为方便，简单灵活，提高了代码的可维护性）
重要的一点：使用的人多，技多不压身！

1)重难点?

a)mybatis 框架在分层架构中的一个定位?
b)Mybatis 框架的应用优势？(简单，灵活)
c)MyBatis 框架核心API？(SqlSession,SqlSessionFactory,SqlSessionFactoryBuilder,…)
d)MyBatis 框架API会话应用的执行过程？(SqlSession->DataSource-Connection-JDBCAPI-SQL)
e)MyBatis 中的动态SQL应用,参数表达式#{}?
f)MyBatis 中的常用配置?(映射文件路径，驼峰命名规则，事务超时时间。)

2)FAQ

a)@Mapper注解的作用是什么？
b)DAO中方法参数为什么有时需要使用@Param注解描述？
c)什么情况下将sql映射写到dao方法上？(推荐简单sql)
d)SQL映射中什么请求下会使用resultType？(简单查询)
e)动态sql的语法结构是怎样的？(参考官网-https://mybatis.org/mybatis-3)

二、第一个mybatis程序

第一步：搭建环境

1 搭建数据库

CREATE DATABASE `mybatis`;

USE'mybatis`;

CREATE TABLE `user `(
`id` INT(20) NOT NULL PRIMARY KEY,
`name` VARCHAR(30) DEFAULT NULL,
`pwd` VARCHAR(30) DEFAULT NULL,
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO `user`(`id `,`name`,`pwd`) VALUES 
(1,'清风','123456'),
(2,'张三','123456'),
(3,'李四','456789')

1.2 新建项目

步骤一：创建一个普通的Maven项目

1.3 删除src 导入依赖

    <!--导入依赖-->
    <dependencies>
        <!--mysqlq驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

1.4 创建模块

选中项目 --> New --> Module…

项目名：

子模块：

这种创建方式有一个好处：子模块不用在导包.

第二步：创建模块

2.编写mybatis的核心配置文件

新建一个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核心配置文件-->
<configuration>
    <!--配置环境-->
     <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?userSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC"/>
                 <property name="username" value="root"/>
                 <property name="password" value="root"/>
             </dataSource>
         </environment>
     </environments>
</configuration>

2.1.编写mybatis工具类

从 XML 中构建 SqlSessionFactory
每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。
SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。
而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。

String resource = "org/mybatis/example/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

package com.cy.utils;

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;

//SqlSessionFactory --> sqlSession
public class MybatisUtils {

    static SqlSessionFactory sqlSessionFactory = null;

    static {
        try {
            //使用Mybatis第一步 ：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();  
        }
    }

    //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例.
    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

第三步：编写(实体类和 Dao接口)

3.1 实体类

package com.cy.pojo;

/**实体类*/
public class User {
    private int id;
    private String name;
    private String pwd;

    public User(){}

    public User(int id,String name,String pwd){
        this.id=id;
        this.name=name;
        this.pwd=pwd;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
     //get、set自己创建
}

3.2 Dao接口

以往我们写接口的方法(这种写法会写很多的JDBC语句) ，使用我们不在使用这种写法

MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。

package com.cy.dao;
import com.cy.pojo.User;
import java.util.List;
/**以前的写法,这种写法会写很多的JDBC
 *MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。
 * 所以这种方法不需要了，不建议写这种
 * */
public class UserDaoImpl implements UserDao {
    public List<User> getUserList(){
        //执行SQL 
        select * from mybatis.user
        //结果集  ResultSet
    }
}

所以我们删除UserDaoImpl ，创建UserDao 类，使用xml映射

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

3.3 接口实现类

接口实现类（由原来的UserDaoImpl转变为一个Mapper配置文件）

这里我们只需记住：
resultMap：字面意思：代表集合
resultType：字面意思：代表类型

<?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">

<!--namespace=绑定一个指定的Dao/Mapper接口-->
<mapper namespace="com.kuang.dao.UserDao">
    <select id="getUserList" resultType="com.kuang.pojo.User"><!--resultType返回一个结果 List<User>-->
    select * from USER
  </select>
</mapper>

3.4 @Test 测试

在test中创建一个测试类：

package com.cy.dao;

import com.cy.pojo.User;
import com.cy.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {

    @Test
    public void test() {
        //第一步获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //执行SQL(绑定接口)
        //方式一：getMapper 
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();

        //方式二：不建议使用
        //List userList = sqlSession.selectlist("com.cy.dao.UserDao.getUserList");

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

        //关闭sqlSession
        sqlSession.close();
    }
}

问题一

运行：

注意点：
org.apache.ibatis.binding.BindingException: Type interface com.kuang.dao.UserDao is not known to the MapperRegistry.

MapperRegistry是什么?（核心配置文件中注册mappers）

解决：
在mybatis-config.xml中配置注册文件

    <!--指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->
    <!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册!-->
    <mappers>
       <mapper resource="com/cy/dao/UserMapper.xml"/>
   </mappers>

问题二：

maven由于他的约定大于配置，所以我们写的配置文件，无法被导出或者生效

解决方案：
在pom中添加：(避免出现)

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties
                    **/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties
                    **/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

可能会遇到的问题：

1.配置文件没有注册
2.绑定接口错误
3.方法名不对
4.返回类型不对
5.Maven导出资源问题
6.xml中不能写中文
7.空指针异常
8.mysql版本8.0和我的不一样

三、 CRUD 增删改查

1.namespace（命名空间）

修改文件名

修改测试类与xml

namespace中的包名要和Dao/Mapper接口的包名一致

2.select(查询)

选择，查询语句；

id：就是对应的namespace中的方法名；

resultType : Sql语句执行的返回值；

parameterType : 参数类型；

1.编写接口

package com.cy.dao;
import com.cy.pojo.User;
import java.util.List;

public interface UserMapper {
   //查询全部用户
    List<User> getUserList();
    //根据ID查询用户
    User getUserById(int id);
}

2.编写对应的mapper中的sql语句

<?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="com.cy.dao.UserMapper">
    <select id="getUserList" resultType="com.cy.pojo.User">
        select * from mybatis.user
    </select>

    <select id="getUserById" parameterType="int" resultType="com.cy.pojo.User">
        select * from mybatis.user where id = #{id}
    </select>
</mapper>

3.测试

    @Test
    public void getUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user=mapper.getUserById(1);
        System.out.println(user);
        //关闭sqlSession
        sqlSession.close();
    }

3. insert(增加)

1.编写接口

2.编写对应的mapper中的sql语句

    <select id="getUserById" parameterType="int" resultType="com.cy.pojo.User">
        select * from mybatis.user where id = #{id}
    </select>
    <!--对象中的属性,可以直接取出来-->
    <insert id="addUser" parameterType="com.cy.pojo.User">
        insert into mybatis.user (id,name,pwd) values (#{id},#{name},#{pwd});
    </insert>

3.测试

    @Test
    public void getUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user=mapper.getUserById(1);
        System.out.println(user);
        //关闭sqlSession
        sqlSession.close();
    }

    @Test
    public void addUser() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int res = mapper.addUser(new User(4,"淡若清风","123456"));
        if (res >0){
            System.out.println("插入成功");
        }
        //增删改一定要提交事务
        sqlSession.commit();
        //关闭sqlSession
        sqlSession.close();
    }

4.update(修改)

1.编写接口

package com.cy.dao;

import com.cy.pojo.User;
import org.apache.ibatis.annotations.Update;

import java.util.List;

public interface UserMapper {
   //查询全部用户
    List<User> getUserList();
    //根据ID查询用户
    User getUserById(int id);
    //insert一个用户
    int addUser(User user);
    //修改用户
    int updateUser(User user);
}

2.编写对应的mapper中的sql语句

    <update id="updateUser" parameterType="com.cy.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id};
    </update>

3.测试

    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        mapper.updateUser(new User(5,"CSND","123123"));

        //增删改一定要提交事务
        sqlSession.commit();
        //关闭sqlSession
        sqlSession.close();
    }

5.delete(删除)

1.编写接口

package com.cy.dao;

import com.cy.pojo.User;
import org.apache.ibatis.annotations.Update;

import java.util.List;

public interface UserMapper {
   //查询全部用户
    List<User> getUserList();
    //根据ID查询用户
    User getUserById(int id);
    //insert一个用户
    int addUser(User user);
    //修改用户
    int updateUser(User user);
    //删除一个用户
    int deleteUser(int id);
}

2.编写对应的mapper中的sql语句

   <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id =#{id};
    </delete>

3.测试


    @Test
    public void deleteUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.deleteUser(5);
        
        //增删改一定要提交事务
        sqlSession.commit();
        //关闭sqlSession
        sqlSession.close();
    }

注意点：

增删改查需要提交事务！

分析错误

1）标签不要匹配错
2）resource绑定mapper，需要使用路径!
3）程序配置文件必须符合规范!
4）NullPointerException，没有注册到资源!
5）输出的xml文件中存在中文乱码问题!
6）maven资源没有导出问题!

Map优化

假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应该考虑使用Map!

1.UserMapper接口

    User getUserById2(Map<String,Object> map);

2.UserMapper.xml

    <!--对象中的属性可以直接取出来 传递map的key-->
    <insert id="addUser2" parameterType="map">
        insert into user (id,name,password) values (#{userid},#{username},#{userpassword})
    </insert>

3.测试

    @Test
    public void addUser2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("userid",5);
        map.put("username","清风");
        
        mapper.addUser2(map);
        //关闭资源
        sqlSession.close();
    }

Map传递参数，直接在sql中取出key即可！【parameter=“map”】

对象传递参数，直接在sql中取出对象的属性即可！【parameter=“Object”】

只有一个基本类型参数的情况下，可以直接在sql中取到

多个参数用Map , 或者注解！

模糊查询

1.Java代码执行的时候，传递通配符% _%

List<User> userList = mapper.getUserLike("%李%");

2.在sql拼接中使用通配符

select * from user where name like "%"#{value}"%"

四、配置解析

核心配置文件

mybatis-config.xml

Mybatis的配置文件包含了会深深影响MyBatis行为的设置和属性信息。

configuration（配置）
    properties（属性）
    settings（设置）
    typeAliases（类型别名）
    typeHandlers（类型处理器）
    objectFactory（对象工厂）
    plugins（插件）
    environments（环境配置）
    	environment（环境变量）
    		transactionManager（事务管理器）
    		dataSource（数据源）
    databaseIdProvider（数据库厂商标识）
    mappers（映射器）

4.1.新建一个项目mybatis02

复制之前的xml和工具类、实体类、接口

去掉不要的部分

package com.cy.dao;
import com.cy.pojo.User;
import java.util.List;
import java.util.Map;
public interface UserMapper {
   //查询全部用户
    List<User> getUserList();
    //根据ID查询用户
    User getUserById(int id);
    //insert一个用户
    int addUser(User user);
    //修改用户
    int updateUser(User user);
    //删除一个用户
    int deleteUser(int id);
}

<?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核心配置文件-->
<configuration>
    <!--配置环境-->
    <environments default="test">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"/>
            <!--配置数据源(连接池)-->
            <dataSource type="POOLED">
                <!--配置连接数据库的四个基本信息-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?userSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    
    <mappers>
       <mapper resource="com/cy/dao/UserMapper.xml"/>
   </mappers>
</configuration>

package com.cy.dao;

import com.cy.pojo.User;
import com.cy.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UserDaoTest {

    @Test
    public void test() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper userDao = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userDao.getUserList();

        for (User user : userList) {
            System.out.println(user);
        }
        //关闭sqlSession
        sqlSession.close();
    }
}

4.2. 环境配置 environments

MyBatis 可以配置成适应多种环境

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境

学会使用配置多套运行环境！

MyBatis默认的事务管理器就是JDBC ，连接池：POOLED

4.3. 属性 properties

我们可以通过properties属性来实现引用配置文件

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

编写一个配置文件
application.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?userSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username=root
password=root

1.可以直接引入外部文件

在核心配置文件中引入

<! --引入外部配置文件-->
<properties resource="application.properties">
    <property name="username" value="root"/>
    <property name="pwd" value="123456"/>
</properties>

2.可以在其中增加一些属性配置
3.如果两个文件有同一个字段，优先使用外部配置文件的

4.4. 类型别名 typeAliases

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置.

意在降低冗余的全限定类名书写。

<!--可以给实体类起别名-->
<typeAliases>
    <typeAlias type="com.kuang.pojo.User" alias="User"/>
</typeAliases>

也可以指定一个包，每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。比如 domain.blog.Author 的别名为 author,；若有注解，则别名为其注解值。
见下面的例子：

<typeAliases>
    <package name="com.kuang.pojo"/>
</typeAliases>

在实体类比较少的时候，使用第一种方式。
如果实体类十分多，建议用第二种扫描包的方式。
第一种可以DIY别名，第二种不行，如果非要改，需要在实体上增加注解。

@Alias("author")
public class Author {
    ...
}

4.5. 设置 Settings

API参考官网：mybatis官网

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

4.6. 其他配置(简单了解即可)

typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins 插件

1.mybatis-generator-core(原始工程（自动生成代码）)

2.mybatis-plus（官网）

3.通用mapper

4.7. 映射器 mappers

既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要来定义 SQL 映射语句了。但首先，我们需要告诉 MyBatis 到哪里去找到这些语句。在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等。例如：

MapperRegistry：注册绑定我们的Mapper文件；

方式一：【推荐使用】

<!--每一个Mapper.xml都需要在MyBatis核心配置文件中注册-->
<mappers>
    <mapper resource="com/cy/dao/UserMapper.xml"/>
</mappers>

方式二：使用class文件绑定注册

<!--每一个Mapper.xml都需要在MyBatis核心配置文件中注册-->
<mappers>
    <mapper class="com.cy.dao.UserMapper"/>
</mappers>

注意点：
接口和他的Mapper配置文件必须同名
接口和他的Mapper配置文件必须在同一个包下

方式三：使用包扫描进行注入：

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

4.8. 作用域和生命周期

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

SqlSessionFactoryBuilder:
1）一旦创建了SqlSessionFactory，就不再需要它了
2）局部变量

SqlSessionFactory:
1）可以理解为：数据库连接池
2）SqlSessionFactory一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建一个实例。
3）因此SqlSessionFactory的最佳作用域是应用作用域（ApplocationContext）。
4）最简单的就是使用单例模式或静态单例模式。

SqlSession：
1）连接到连接池的一个请求
2）SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
3）用完之后需要赶紧关闭，否则资源被占用！

这里面的每一个Mapper，就代表一个具体的业务!

五、ResultMap结果集映射

解决属性名和字段名不一致的问题

1.问题一：

数据库中的字段

新建一个项目，拷贝之前的，测试实体类字段不一致的情况

修改实体类的pwd改为password

老样子清空不要的内容：

public interface UserMapper {
    //根据ID查询用户
    User getUserById(int id);
}

<?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="com.cy.dao.UserMapper">
    <select id="getUserById" resultType="com.cy.pojo.User">
        select * from mybatis.user where id = #{id}
    </select>
</mapper>

创建测试类：

package com.cy.dao;

import com.cy.pojo.User;
import com.cy.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {

    @Test
    public void test() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);

        //关闭sqlSession
        sqlSession.close();
    }
}

运行，我们可以发现问题：password为null

解决方法：

5.1.起别名：

<?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="com.cy.dao.UserMapper">
    <select id="getUserById" resultType="com.cy.pojo.User">
        select id,name,pwd as password from mybatis.user where id = #{id}
    </select>
</mapper>

5.2.resultMap(结果集映射)

在xml配置

    <!--给实体类起别名-->
    <typeAliases>
        <package name="com.cy.pojo"/>
    </typeAliases>

怎么把pwd转换成password呢？

id name pwd
id name password

创建结果集映射

<?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="com.cy.dao.UserMapper">

    <!--结果集映射-->
    <!--id对应取的别名，type实体类类名-->
    <resultMap id="UserMap" type="user">
        <!-- column数据库中的字段，property实体类中的属性-->
        <!--<result column="id" property="id"/>
        <result column="name" property="name"/>-->
        <!--哪里不同映射哪里-->
        <result column="pwd" property="password"/>
    </resultMap>

    <select id="getUserById" resultMap="UserMap">
        select * from mybatis.user where id = #{id}
    </select>
</mapper>

1）resultMap 元素是 MyBatis 中最重要最强大的元素。

2）ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

3）ResultMap 的优秀之处——你完全可以不用显式地配置它们。

4）如果这个世界总是这么简单就好了。

六、日志

6.1日志工厂

如果一个数据库操作，出现了异常，我们需要排错，日志就是最好的助手！

曾经：sout、debug

现在：日志工厂

SLF4J
LOG4J 【掌握】
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING 【掌握】
NO_LOGGING

在MyBatis中具体使用哪一个日志实现，在设置中设定

STDOUT_LOGGING标准日志输出

配置：

在mybatis核心配置文件中，配置我们的日志！
一个字都不能错，一个多余的空格都不能有！

标准的日志工厂实现

    <!--标准的日志工厂实现-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

运行测试类：

6.2 Log4j

什么是Log4j？
百度百科：Log4j详细解析

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

1.先导入log4j的包

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

2.log4j.properties

创建log4j配置文件

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n
#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/rzp.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n
#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sq1.PreparedStatement=DEBUG

3.配置settings为log4j实现

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

4.测试运行

Log4j简单使用

1.在要使用Log4j的类中，导入包 import org.apache.log4j.Logger;

2.日志对象，参数为当前类的class对象

Logger logger = Logger.getLogger(UserDaoTest.class);

3.测试

package com.cy.dao;

import com.cy.pojo.User;
import com.cy.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.Test;
import java.util.List;

public class UserDaoTest {

    //日志对象，参数为当前类的class对象
    Logger logger = Logger.getLogger(UserDaoTest.class);

    @Test
    public void getUserLike() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        logger.info("info: 进入getUserLike方法成功！");

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);

        //关闭sqlSession
        sqlSession.close();
    }

    @Test
    public void testLog4j(){
        logger.info("info: 进入了testLog4j方法");
        logger.debug("debug:进入了testLog4j");
        logger.error("error:进入了testLog4j");
    }
}

3.日志级别

logger.info("info: 测试log4j");
logger.debug("debug: 测试log4j");
logger.error("error:测试log4j");

七、分页

思考：

为什么分页？(减少数据的处理量)

7.1 使用Limit分页

◆ 每页显示2个，从0页开始查

SELECT * from user limit 0,2

◆ 从0开始，3页开始查，

SELECT * from user limit 3

使用MyBatis实现分页，核心SQL

1.接口

package com.cy.dao;

import com.cy.pojo.User;
import java.util.List;
import java.util.Map;

public interface UserMapper {
    //根据ID查询用户
    User getUserById(int id);

    //分页
    List<User> getUserByLimit(Map<String,Integer> map);
}

2.Mapper.xml


<select id="getUserByLimit" parameterType="map" resultMap="UserMap">
    select * from user limit #{startIndex},#{pageSize}
select>

3.测试

    @Test
    public void getUserByLimit() {
        //获取sqlSession
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        //调用方法
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("startIndex", 0);//从0开始
        map.put("pageSize", 2);//显示2位
        List<User> list = mapper.getUserByLimit(map);
        for (User user : list) {
            System.out.println(user);
        }
    }

7.2RowBounds分页(理解就好，基本不用)

不再使用SQL实现分页
1.接口

    //RowBounds分页
    List<User> getUserByRowBounds();

2.mapper.xml

    <!--RowBounds分页-->
    <select id="getUserByRowBounds" resultMap="UserMap">
        select * from user
    </select>

3.测试

 @Test
    public void getUserByRowBounds(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //RowBounds实现
        RowBounds rowBounds = new RowBounds(1, 2);
        //通过Java代码层面实现分页
        List<User> userList = sqlSession.selectList("com.cy.dao.UserMapper.getUserByRowBounds", null, rowBounds);
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

7.3 分页插件(了解就好，需要的时候在查看文档使用)

分页插件官网

八、注解开发

8.1、面向接口编程

大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程。
◆ 根本原因∶解耦，可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性更好。
◆ 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;
◆ 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

关于接口的理解

◆ 接口从更深层次的理解，应是定义(规范，约束）与实现(名实分离的原则）的分离。
◆ 接口的本身反映了系统设计人员对系统的抽象理解。

接口应有两类:

◆ 第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class);
◆ 第二类是对一个个体某一方面的抽象，即形成一个抽象面(interface) ;
一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向区别

◆ 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法．
◆ 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程)为单位，考虑它的实现.
◆ 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程)不是一个问题.更多的体现就是对系统整体的架构

8.2 使用注解开发

1.新建一个mybatis-04 Maven项目

2.准备项目的基本架构

接口类

package com.cy.dao;
public interface UserMapper {
}

实体类

public class User {
    private int id;
    private String name;
    private String password;

    public User() {}
    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

   //自己导入get、set、toString
}

工具类

package com.cy.utils;
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;

//SqlSessionFactory --> sqlSession
public class MybatisUtils {
    static SqlSessionFactory sqlSessionFactory = null;
    static {
        try {
            //使用Mybatis第一步 ：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

application.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?userSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username=root
password=root

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核心配置文件-->
<configuration>

    <!--引入外部配置文件-->
    <properties resource="application.properties"/>

    <!--标准的日志工厂实现-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    
    <!--给实体类起别名-->
    <typeAliases>
        <package name="com.cy.pojo"/>
    </typeAliases>

    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"/>
            <!--配置数据源(连接池)-->
            <dataSource type="POOLED">
                <!--配置连接数据库的四个基本信息-->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

</configuration>

准备工作完成

3.开始学习

3.1 配置接口

package com.cy.dao;

import com.cy.pojo.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface UserMapper {
    @Select("select * from user")
    List<User> getUsers();
}

3.2 在核心配置文件xml中绑定接口

<mappers>
    <mapper class="com.cy.dao.UserMapper"/>
</mappers>

3.3 创建测试类

package com.cy.dao;

import com.cy.pojo.User;
import com.cy.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserMapperTest {
    @Test
    public void test(){
        SqlSession sqlsession = MybatisUtils.getSqlSession();
        //底层主要应用反射
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
        List<User> users = mapper.getUsers();
        for (User user : users) {
           System.out.println(user);
       }
       sqlsession.close();
    }
}

运行结果：

我们可以发现问题：password=null

底层分析

我们可以发现我的所有配置文件都被注入到了sqlSession里面，它会去读取。

通过反射我们可以拿到全类名，以及它的全部属性。

注解小结

本质：是我们的反射机制实现
底层：动态代理！

可以理解为：租客、房东、中介

MyBatis详细执行流程：

九、注解的增删改查

把SqlSession 设置为true
一旦设置为true 以后的所有东西都不用手动

1.重新

◆ 修改工具类

public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession(true);
    }

◆ 修改接口

//方法存在多个参数，所有的参数前面必须加上@Param(" ")注解
    @Select("select * from user where id=#{id}")
    User getUserByID(@Param("id")int id,@Param("name")String name);

◆ 测试

package com.cy.dao;

import com.cy.pojo.User;
import com.cy.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;

public class UserMapperTest {
    @Test
    public void test(){
        SqlSession sqlsession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
       
        User userById = mapper.getUserByID(1,"清风");
        System.out.println(userById);

       sqlsession.close();
    }
}

2.添加

◆ 接口

    @Insert("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
    int addUser(User user);

◆ 测试

    @Test
    public void insert(){
        SqlSession sqlsession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);

        mapper.addUser(new User(5,"李刚","123123"));
        sqlsession.close();
    }

3.修改

◆ 接口

    @Update({"update user set name=#{name}.pwd=#{password} where id=#{id}"})
    int updateUser(User user);

◆ 测试

    @Test
    public void update(){
        SqlSession sqlsession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);

        mapper.updateUser(new User(5,"马云","123123"));
        sqlsession.close();
    }

4.删除

◆ 接口

    @Delete( "delete from user where id = #{id}")
    int deleteUser(@Param("id") int id);

◆ 测试

    @Test
    public void detele(){
        SqlSession sqlsession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);

        mapper.deleteUser(5);
        sqlsession.close();
    }

小结

我们必须要将接口绑定到我们的核心配置文件中！

使用Class文件绑定接口注册

    <mappers>
        <mapper class="com.cy.dao.UserMapper"/>
       
       
    mappers>

注意点：
◆ 接口和他的Mapper配置文件必须同名!
◆ 接口和他的Mapper配置文件必须在同一个包下!

关于@Param( )注解

◆ 基本类型的参数或者String类型，需要加上
◆ 引用类型不需要加
◆ 如果只有一个基本类型的话，可以忽略，但是建议大家都加上
◆ 我们在SQL中引用的就是我们这里的@Param()中设定的属性名

◆ #{} 和 ${}的区别：
${} 注入什么就是什么，且如果是简单类型的值需要用 value 来接收
#{} 将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号

#方式能够很大程度防止sql注入；$方式无法防止Sql注入。
$方式一般用于传入数据库对象，例如传入表名。

一般能用#的就别用$ 。MyBatis排序时使用order by 动态参数时需要注意，用$而不是#。

十、Lombok(插件(偷懒用的))

Lombok的简介

Lombok是一款Java开发插件，使得Java开发者可以通过其定义的一些注解来消除业务工程中冗长和繁琐的代码，尤其对于简单的Java模型对象（POJO)。在开发环境中使用Lombok插件后，Java开发人员可以节省出重复构建，诸如hashCode和equals这样的方法以及各种业务对象模型的accessor和ToString等方法的大量时间。对于这些方法，它能够在编译源代码期间自动帮我们生成这些方法，并没有如反射那样降低程序的性能。

环境准备：

想要体验—把Lombok的话，得先在自己的开发环境中安装上对应的插件。

1.在IDEA中安装Lombok插件

2.在项目中导入lombok的jar包

在使用lombok注解的时候记得要导入lombok.jar包到工程
如果使用的是Maven的工程项目的话，要在其pom.xml中添加依赖如下:

<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>

3.在程序上加注解

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val

这是我们之前的实体类

package com.cy.pojo;

/**实体类*/
public class User {
    private int id;
    private String name;
    private String password;

    public User() {
    }

    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

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

    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 String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

我们使用Lombok优化

package com.cy.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**实体类*/
@Data //无参构造，get、set、tostring、hashcode，equals
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
public class User {
    private int id;
    private String name;
    private String password;
}

常用的注解

@Data //无参构造，get、set、tostring、hashcode，equals
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
@ToString //toString方法
@EqualsAndHashCode //HashCode
@Getter //放在类上生成所有get方法，放在字段只生成当前单独的get方法

Lombok的优缺点优点:

1.能通过注解的形式自动生成构造器、getter/setter、equals、hashcode、toString等方法，提高了一定的开发效率
2.让代码变得简洁，不用过多的去关注相应的方法
3.属性做修改时，也简化了维护为这些属性所生成的getter/setter方法等

缺点:

1.不支持多种参数构造器的重载
2.虽然省去了手动创建getter/setter方法的麻烦，但大大降低了源代码的可读性和完整性，降低了阅读源代码的舒适度

总结：

Lombok虽然有很多优点，但Lombok更类似于一种IDE插件，项目也需要依赖相应的jar包。Lombok依赖jar包是因为编译时要用它的注解，为什么说它又类似插件?因为在使用时，eclipse或Intelli IDEA都需要安装相应的插件，在编译器编译时通过操作AST(抽象语法树)改变字节码生成，变向的就是说它在改变java语法。
它不像spring的依赖注入或者mybatis的ORM一样是运行时的特性，而是编译时的特性。这里我个人最感觉不爽的地方就是对插件的依赖!因为Lombok只是省去了一些人工生成代码的麻烦，但IDE都有快捷键来协助生成getter/setter等方法，也非常方便。

知乎上有位大神发表过对Lombok的一些看法:
这是一种低级趣味的插件，不建议使用。5AVa发展到今天，各种插件层出不穷，如何甄别各种插件的优劣?能从架构上优化你的设计的，能提高应用程序性能的，实现高度封装可扩展的…，像l ombrok这种，像这种插件，已经不仅仅是插件了，改变了你如何编写源码，事实上，少去了的代码，你写上去又如何?如果JAVA家族到处充斥这样的东西，那只不过是一坨披着金属颜色的屎，迟早会被其它的语言取代。

虽然话糙但理确实不糙，试想一个项目有非常多类似Lombok这样的插件，个人觉得真的会极大的降低阅读源代码的舒适度。虽然非常不建议在属性的getter/setter写一些业务代码，但在多年项目的实战中，有时通过给getter/setter加一点点业务代码，能极大的简化某些业务场景的代码。所谓取舍，也许就是这时的舍弃一定的规范，取得极大的方便。

我现在非常坚信一条理念，任何编程语言或插件，都仅仅只是工具而已，即使工具再强大也在于用的人，就如同小米加步枪照样能嬴飞机大炮的道理一样。结合具体业务场景和项目实际情况，无需一味追求高大上的技术，适合的才是王道。

Lombok有它的得天独厚的优点，也有它避之不及的缺点，熟知其优缺点，在实战中灵活运用才是王道。

十一、多表查询(多对一、一对多)

一、复杂查询环境搭建

1.导入lombok
2.新建实体类Teacher,Student
3.建立Mapper接口
4.建立Mapper.xml文件
5.在核心配置文件中绑定注册我们的Mapper接口或者文件【方式很多，随心选】
6.测试查询是否能够成功

搭建环境

◆ 多个学生，对应一个老师
◆ 对于学生这边而言，关联，多个学生，关联一个老师【多对一】
◆ 对于老师而言，集合，一个老师，有很多学生【一对多】

1.数据库创建teacher表和student表

CREATE TABLE `teacher` (
`id`INT (10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY( `id`),
）ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `teacher` (`id`, `name`) VALUES ('1', '清风老师');


CREATE TABLE `student` (
`id`INT (10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`tid` INT(10) DEFAULT NULL,
PRIMARY KEY( `id`),
KEY `fktid` (`tid`),
CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher`(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');
 )

2.新建一个项目

项目下载：
链接：https://pan.baidu.com/s/1erHaT_avxIKlhRGMb-qlfA
提取码：b3qb

表结构：

工具类

package com.cy.utils;

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;

//SqlSessionFactory --> sqlSession
public class MybatisUtils {

    static SqlSessionFactory sqlSessionFactory = null;

    static {
        try {
            //使用Mybatis第一步 ：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

Student 类

package com.cy.pojo;
public class Student {
    private int id;
    private String name;

    //学生需要关联一个老师！
    private Teacher teacher;
}

Teacher 类

package com.cy.pojo;
import lombok.Data;
@Data
public class Teacher {
    private int id;
    private String name;
}

StudentMapper 接口

package com.cy.dao;

public interface StudentMapper {
}

TeacherMapper 接口

package com.cy.dao;

import com.cy.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

public interface TeacherMapper {
    @Select("select * from teacher where id = #{tid}")
    Teacher getTeacher(@Param("tid") int id);
}

配置数据库连接

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?userSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username=root
password=root

配置环境

<?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核心配置文件-->
<configuration>

    <!--引入外部配置文件-->
    <properties resource="application.properties"/>

    <!--标准的日志工厂实现-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    
    <!--给实体类起别名-->
    <typeAliases>
        <package name="com.cy.pojo"/>
    </typeAliases>

    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"/>
            <!--配置数据源(连接池)-->
            <dataSource type="POOLED">
                <!--配置连接数据库的四个基本信息-->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper class="com.cy.dao.TeacherMapper"/>
        <mapper class="com.cy.dao.StudentMapper"/>
    </mappers>

</configuration>

测试类：

package com.cy.dao;

import com.cy.pojo.Teacher;
import com.cy.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

public class MyTest {
    public static void main(String[] args) {
        SqlSession sqlSession= MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);
        sqlSession.close();
    }
}

二、多对一

1.查询所有的学生信息，以及对应的老师的信息！

分析sql查询语句

select s.id,s.name,t.name from student s,teacher t where s.tid =t.id;

修改接口

package com.cy.dao;

import com.cy.pojo.Student;
import java.util.List;

public interface StudentMapper {
    //查询所有的学生信息，以及对应的老师的信息！
    public List<Student> getStudent();
}

配置StudentMapper.xml

<mapper namespace="com.cy.dao.StudentMapper">
    <select id="getStudent" resultType="Student">
        select * from student;
    </select>
</mapper>

测试：

 @Test
    public void testStudent(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> studentList = mapper.getStudent();
        for (Student student:studentList){
            System.out.println(student);
        }
        sqlSession.close();
    }

运行结果：

2. 按照查询嵌套处理

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--
     思路：
        1. 查询所有的学生信息
        2. 根据查询出来的学生的tid寻找特定的老师 (子查询)
    -->
<mapper namespace="com.cy.dao.StudentMapper">
    <!--先查学生-->
    <select id="getStudent" resultMap="StudentTeacher">
        select * from student;
    </select>
    <!--单独处理学生中老师的字段-->
    <resultMap id="StudentTeacher" type="Stuent">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <!--复杂的属性，我们需要单独出来
          对象：association /关联（association）
          集合：collection
          -->
        <collection property="teacher" column="tid" javaType="teacher" select="getTeacher"/>
    </resultMap>
    <!--在查老师-->
    <select id="getTeacher" resultType="Teacher">
    select * from teacher where id=#{id}
</select>
</mapper>

property：映射到列结果的字段或属性
column：数据库中的列名或者列的别名
javaType：一个java类的完全限定名，或一个类型别名。
jdbcType：JDBC类型
resultMap：结果映射的 ID，可以将嵌套的结果集映射到一个合适的对象树中。

测试:

3.按照结果嵌套处理

    <!--按照结果集查询-->
    <select id="getStudent2" resultMap="StudentTeacher2">
        select s.id sid,s.name sname,t.id tid,t.name tname
        from student s,teacher t
        where s.tid =t.id
    </select>
    <resultMap id="StudentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="id" column="tid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="id" column="tid"/>
            <result property="name" column="tname"/>
        </association>
    </resultMap>

第一种可以理解为：查出老师和学生，通过子查询查老师
第二种可以理解为: 先查出学生的所有值，对于具体的tname，再去teacher里面查

回顾Mysql多对一查询方式:

◆ 子查询（按照查询嵌套）
◆ 联表查询（按照结果嵌套）

三、一对多

一个老师多个学生；
对于老师而言，就是一对多的关系；

1.环境搭建，和之前一样

新建一个项目或者把刚刚写的内容清理和开始的模板项目一样

这里就省略环境搭建了，和上面一样，把写的查询删除就可以了

修改实体类

package com.cy.pojo;

import lombok.Data;
import java.util.List;

@Data
public class Teacher {
    private int id;
    private String name;

    //一个老师拥有多个学生
    private List<Student> students;
}

package com.cy.pojo;

import lombok.Data;

@Data
public class Student {
    private int id;
    private String name;
    private int teacher;
}

2. 按照结果嵌套处理

接口

public interface TeacherMapper {

    Teacher getTeacher(@Param("tid") int id);
}

    <!--按结果嵌套查询-->
    <select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid,s.name sname,t.name tname,t.id tid
        from student s ,teacher t
        where s.tid = t.id and t.id =#{tid}
    </select>

    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--复杂的属性，我们需要单独处理 对象：association 集合：collection
        javaType=""指定属性的类型！
        集合中的泛型信息，我们使用ofType获取
        -->
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

测试：

    @Test
    public void test(){
        SqlSession sqlSession= MybatisUtils.getSqlSession();

        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);

        System.out.println(teacher);
        sqlSession.close();
    }

3.按照查询嵌套处理

    <!--=================================================-->
    <select id="getTeacher2" resultMap="TeacherStudent2">
        select * from teacher where id =#{tid}
    </select>
    <resultMap id="TeacherStudent2" type="Teacher">
        <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
    </resultMap>
    <select id="getStudentByTeacherId" resultType="Student">
        select * from student where tid = #{tid}
    </select>

小结

1.关联 - association 【多对一】
2.集合 - collection 【一对多】
3.javaType & ofType

◆ JavaType用来指定实体类中的类型
◆ ofType用来指定映射到List或者集合中的pojo类型，泛型中的约束类型

注意点：

◆ 保证SQL的可读性，尽量保证通俗易懂
◆ 注意一对多和多对一，属性名和字段的问题
◆ 如果问题不好排查错误，可以使用日志，建议使用Log4j

面试高频

◆ Mysql引擎
◆ InnoDB底层原理
◆ 索引
◆ 索引优化

十二、动态SQL

什么是动态SQL：动态SQL就是根据不同的条件生成不同的SQL语句

所谓的动态SQL，本质上还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。

利用动态 SQL，可以彻底摆脱这种痛苦。
动态SQL元素和STL或基于类似XML的文本处理器相似。在MyBatis之前的版本中，有很多元素需要花时间了解。MyBatis 3 大大精简了元素种类，现在只需学习原来一半的元素便可。MyBatis采用功能强大的基于OGNL的表达式来淘汰具它大部分无素。

if
choose (when，otherwise)
trim (where，set)
foreach

搭建环境

CREATE TABLE `blog`  (
  `id` varchar(50) NOT NULL COMMENT '博客id',
  `title` varchar(100) NOT NULL COMMENT '博客标题',
  `author` varchar(30) NOT NULL COMMENT '博客作者',
  `create_time` DATETIME NOT NULL COMMENT '创建时间',
  `views` INT(30) NOT NULL COMMENT '浏览量',
)ENGINE=INNODB DEFAULT CHARSET=utf8

创建一个基础工程

1.导包

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
        </dependency>
                <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties
                    **/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties
                    **/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
</project>

2.编写配置文件

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?userSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username=root
password=root

<?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核心配置文件-->
<configuration>

    <!--引入外部配置文件-->
    <properties resource="application.properties"/>

    <!--标准的日志工厂实现-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
         <!--是否开启自动驼峰命名规则(camel case)映射-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    
    <!--给实体类起别名-->
    <typeAliases>
        <package name="com.cy.pojo"/>
    </typeAliases>

    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"/>
            <!--配置数据源(连接池)-->
            <dataSource type="POOLED">
                <!--配置连接数据库的四个基本信息-->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
<mappers>
    <mapper class="com.cy.dao.BlogMapper"/>
</mappers>
</configuration>

创建工具类

package com.cy.utils;

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;

//SqlSessionFactory --> sqlSession
public class MybatisUtils {

    static SqlSessionFactory sqlSessionFactory = null;

    static {
        try {
            //使用Mybatis第一步 ：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlSession(){
        //提交事务
        return sqlSessionFactory.openSession(true);
    }
}

创建工具类，生成随机的id

package com.cy.utils;

import org.junit.Test;

import java.util.UUID;

//用UID方法生成随机的ID
@SuppressWarnings("all")//预制警告(让警告不显示)
public class IDutils {
    public static String getID(){
        return UUID.randomUUID().toString().replaceAll("-"," ");
    }
    //测试
    @Test
    public void test(){
        System.out.println(IDutils.getID());
    }
}

3.编写实体类

import lombok.Data;

import java.util.Date;

@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;//属性名和字段名不一致
    private int views;
}

4.编写实体类对应Mapper接口和Mapper.xml文件

package com.cy.dao;

public interface BlogMapper {
    //插入数据
    int addBlog(Blog blog);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cy.dao.BlogMapper">
    <insert id="addBlog" parameterType="blog">
        insert into blog (id, title,author,create_time,views)
        values (#{id},#{title}, #{author}, #{createTime}, #{views})
    </insert>
</mapper>

创建一个测试类：
插入数据

public class MyTest {
    @Test
    public void addInitBlog(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        Blog blog=new Blog();
        blog.setId(IDutils.getID());
        blog.setTitle("Mybatis");
        blog.setAuthor("淡若清风");
        blog.setCreateTime(new Date());
        blog.setViews(9999);

        mapper.addBlog(blog);

        blog.setId(IDutils.getID());
        blog.setTitle("JAVA");
        mapper.addBlog(blog);

        blog.setId(IDutils.getID());
        blog.setTitle("Spring5");
        mapper.addBlog(blog);

        blog.setId(IDutils.getID());
        blog.setTitle("微服务");
        mapper.addBlog(blog);
    }
}

1.动态SQL IF

概述：

使用动态 SQL 最常见情景是根据条件包含 where 子句的一部分。比如：

<select id="findActiveBlogWithTitleLike"
     resultType="Blog">
  SELECT * FROM BLOG
  WHERE state = ‘ACTIVE’
  <if test="title != null">
    AND title like #{title}
  </if>
</select>

这条语句提供了可选的查找文本功能。如果不传入 “title”，那么所有处于 “ACTIVE” 状态的 BLOG 都会返回；如果传入了 “title” 参数，那么就会对 “title” 一列进行模糊查找并返回对应的 BLOG 结果（细心的读者可能会发现，“title” 的参数值需要包含查找掩码或通配符字符）。

如果希望通过 “title” 和 “author” 两个参数进行可选搜索该怎么办呢？首先，我想先将语句名称修改成更名副其实的名称；接下来，只需要加入另一个条件即可。

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG WHERE state = ‘ACTIVE’
  <if test="title != null">
    AND title like #{title}
  </if>
  <if test="author != null and author.name != null">
    AND author_name like #{author.name}
  </if>
</select>

看完概述开始编写：

把刚刚插入的JAVA views值改为1000

查询博客

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cy.dao.BlogMapper">
    <insert id="addBlog" parameterType="blog">
        insert into blog(id, title, author, create_time, views)
        values (#{id},#{title},#{author},#{createTime},#{views});
    </insert>

    <select id="queryBlogIF" parameterType="map" resultType="blog">
        <!--1=1是为了where后所有判断条件都不符合时，依然可以执行查询而不报错-->
        select * from blog where 1=1

        <!--判断是否为空，不为空就执行拼接-->
        <!--sql语句： select * from blog where 1=1 and title ="java"-->
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author =#{author}
        </if>
    </select>
</mapper>

package com.cy.dao;

import com.cy.pojo.Blog;

import java.util.List;
import java.util.Map;

public interface BlogMapper {
    //插入数据
    int addBlog(Blog blog);
    
    //查询博客
    List<Blog> queryBlogIF(Map map);
}

测试：

    @Test
    public void queryBlogIF(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();
        //map.put("title","JAVA");
        map.put("author","淡若清风");

        List<Blog> blogs=mapper.queryBlogIF(map);
        for (Blog blog:blogs){
            System.out.println(blog);
        }
        sqlSession.close();
    }

2.动态SQL choose、when、otherwise

概述：

有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。

还是上面的例子，但是策略变为：传入了 “title” 就按 “title” 查找，传入了 “author” 就按 “author” 查找的情形。若两者都没有传入，就返回标记为 featured 的 BLOG（这可能是管理员认为，与其返回大量的无意义随机 Blog，还不如返回一些由管理员精选的 Blog）。

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG WHERE state = ‘ACTIVE’
  <choose>
    <when test="title != null">
      AND title like #{title}
    </when>
    <when test="author != null and author.name != null">
      AND author_name like #{author.name}
    </when>
    <otherwise>
      AND featured = 1
    </otherwise>
  </choose>
</select>

3.动态SQL trim、where、set

概述：

前面几个例子已经方便地解决了一个臭名昭著的动态 SQL 问题。现在回到之前的 “if” 示例，这次我们将 “state = ‘ACTIVE’” 设置成动态条件，看看会发生什么。

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG
  WHERE
  <if test="state != null">
    state = #{state}
  </if>
  <if test="title != null">
    AND title like #{title}
  </if>
  <if test="author != null and author.name != null">
    AND author_name like #{author.name}
  </if>
</select>

如果没有匹配的条件会怎么样？最终这条 SQL 会变成这样：

SELECT * FROM BLOG
WHERE

这会导致查询失败。如果匹配的只是第二个条件又会怎样？这条 SQL 会是这样:

SELECT * FROM BLOG
WHERE
AND title like ‘someTitle’

这个查询也会失败。这个问题不能简单地用条件元素来解决。这个问题是如此的难以解决，以至于解决过的人不会再想碰到这种问题。

MyBatis 有一个简单且适合大多数场景的解决办法。而在其他场景中，可以对其进行自定义以符合需求。而这，只需要一处简单的改动：

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG
  <where>
    <if test="state != null">
         state = #{state}
    </if>
    <if test="title != null">
        AND title like #{title}
    </if>
    <if test="author != null and author.name != null">
        AND author_name like #{author.name}
    </if>
  </where>
</select>

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

如果 where 元素与你期望的不太一样，你也可以通过自定义 trim 元素来定制 where 元素的功能。比如，和 where 元素等价的自定义 trim 元素为：

<trim prefix="WHERE" prefixOverrides="AND |OR ">
  ...
</trim>

编写代码分析：

choose 条件查询

接口

    //查询博客Choose
    List<Blog> queryBlogChoose(Map map);

    <select id="queryBlogChoose" parameterType="map" resultType="blog">
        select * from blog

        <where>
            <choose>
                
                <when test="title != null">
                    title=#{title}
                when>
                <when test="author != null">
                    and author= #{author}
                when>
                
                <otherwise>
                    and views =#{views}
                otherwise>
            choose>
        where>
    select>

测试：

@Test
    public void queryBlogChoose(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();
       // map.put("title", "java");
        map.put("author", "淡若清风");
        map.put("views", 9999);
        
        List<Blog> blogs=mapper.queryBlogChoose(map);
        for (Blog blog:blogs){
            System.out.println(blog);
        }
        sqlSession.close();
    }

update更新博客（ trim）

接口

    //更新博客
    int updateBlog(Map map);

<update id="updateBlog" parameterType="map">
        update  blog
        <set><!--和where差不多，set是发现 ，就给你去掉-->
            <if test="title !=null">
                title = #{title},
            </if>
            <if test="author != null">
                author=#{author}
            </if>
        </set>
        where id= #{id}
    </update>

测试：

    @Test
    public void updateBlog(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();
        map.put("title", "java2");
        map.put("author", "淡若清风2");
        map.put("id", "80ae0f8e fd78 41bf bc9e 97ec174aee46");
        //map.put("views", 9999);

        mapper.updateBlog(map);

        sqlSession.close();
    }

所谓的动态SQL，本质还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码

这个例子中，set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

注意事项：

◆ 最好基于单标来定义SQL片段
◆ 不要存在where标签

动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了

建议：

◆ 先在Mysql中写出完整的SQL，再对应的去修改成我们的动态SQL实现通用即可。

SQL片段

有的时候，我们可能会将一些功能的部分抽取出来，方便复用!

1.使用SQL标签抽取公共的部分

  <sql id="if-title-author">
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author =#{author}
        </if>
    </sql>

2.在需要使用的地方使用include标签即可

 <select id="queryBlogIF" parameterType="map" resultType="blog">
        select * from blog
        <where>
            <include refid="if-title-author"></include>
        </where>
    </select>

注意事项：

◆ 最好基于单标来定义SQL片段
◆ 不要存在where标签

Foreach

参考:

//select * from user where 1=1 and (id=1 or id=2 or id=3)
select * from user where 1=1 and
<foreach item="id" in collection="ids"
     open="(" separator="or" close=")">
   </foreach>

查询第1-2-3号记录的博客

为了测试方便：我们先把博客的id改为1 2 3 4

接口

    //查询第1-2-3号记录的博客
    List<Blog> queryBlogForeach(Map map);

 <!--
    select * from user where 1=1 and (id=1 or id=2 or id=3)
    我们现在传递一个map，这个map中可以存一个集合
    -->
    <select id="queryBlogForeach" parameterType="map" resultType="blog">
        select * from blog
        <where>
            <!--collection="ids"集合  item="id"从集合中遍历出来每一项的名字为id
            遍历：
            open=""以什么开始，close=""关闭，separator=""分隔符
            -->
            <foreach collection="ids" item="id" open="and (" close=")" separator="or">
                    id= #{id}
            </foreach>
        </where>
    </select>

测试：

 @Test
    public void queryBlogForeach(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();

        ArrayList<Integer> ids = new ArrayList<>();
        ids.add(1);
        ids.add(2);
        ids.add(3);

        map.put("ids", ids);
        List<Blog> blogs = mapper.queryBlogForeach(map);
        for (Blog b1og : blogs) {
            System.out.println(b1og);
        }
            sqlSession.close();
    }

动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了

建议：

◆ 先在Mysql中写出完整的SQL，再对应的去修改成我们的动态SQL实现通用即可

十三、缓存

查询：连接数据库，耗资源
◆ 一次查询的结果，给他暂存一个可以直接取到的地方 --> 内存：缓存

我们再次查询的相同数据的时候，直接走缓存，不走数据库了

1.什么是缓存[Cache]？

◆ 存在内存中的临时数据
◆ 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库文件）查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题

2.为什么使用缓存？

◆ 减少和数据库的交互次数，减少系统开销，提高系统效率

3.什么样的数据可以使用缓存？

◆ 经常查询或不经常改变的数据【可以使用缓存】

Mybatis缓存

◆ MyBatis包含- - 个非常强大的查询缓存特性,它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
◆ MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
      • 默认情况下，只有一 -级缓存开启。 (SqlSession级别的缓存，也称为本地缓存)
      • 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
      • 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存。

一级缓存

一级缓存也叫本地缓存：SqlSession
与数据库同一次会话期间查询到的数据会放在本地缓存中
以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库

1.1配置环境

新建一个mybatis-08项目

表结构如下：

配置环境：

mybatis-config.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核心配置文件-->
<configuration>

    <!--引入外部配置文件-->
    <properties resource="application.properties"/>

    <!--标准的日志工厂实现-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    
    <!--给实体类起别名-->
    <typeAliases>
        <package name="com.cy.pojo"/>
    </typeAliases>

    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"/>
            <!--配置数据源(连接池)-->
            <dataSource type="POOLED">
                <!--配置连接数据库的四个基本信息-->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
<mappers>
    <mapper class="com.cy.dao.UserMapper"/>
</mappers>
</configuration>

application.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?userSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
username=root
password=root

pom.xml

 <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
        </dependency>
         <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties
                    **/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties
                    **/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

工具类

package com.cy.utils;

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;

//SqlSessionFactory --> sqlSession
public class MybatisUtils {

    static SqlSessionFactory sqlSessionFactory = null;

    static {
        try {
            //使用Mybatis第一步 ：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession(true);
    }
}

创建一个实体类

package com.cy.pojo;
import lombok.Data;
@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}

创建接口和xml

UserMapper

public interface UserMapper {
   //根据id查询用户
   User queryUserById(@Param("id") int id);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cy.dao.UserMapper">
    <select id="queryUserById" resultType="user">
        select * from user where id = #{id}
    </select>
</mapper>

测试：

package com.cy.dao;

import com.cy.pojo.User;
import com.cy.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class MyTest {
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user = mapper.queryUserById(1);
        System.out.println(user);

        User user2 = mapper.queryUserById(1);
        System.out.println(user2);

        System.out.println(user==user2);

        sqlSession.close();
    }
}

测试步骤：

1.开启日志！
2.测试在一个Sesion中查询两次相同记录
3.查看日志输出

缓存失效的情况：

1.查询不同的东西

2.增删改操作，可能会改变原来的数据，所以必定会刷新缓存

    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user = mapper.queryUserById(1);
        System.out.println(user);

        User user2 = mapper.queryUserById(2);
        System.out.println(user2);

        System.out.println(user==user2);

        sqlSession.close();
    }

我们在中间加一条语句，继续测试生效情况

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String pwd;
}

public interface UserMapper {
   //根据id查询用户
   User queryUserById(@Param("id") int id);

   int updateUser(User user);
}

    <update id="updateUser" parameterType="user">
        update user set name=#{name}, pwd=#{pwd} where id = #{id};
    update>

测试：

@Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user = mapper.queryUserById(1);
        System.out.println(user);

        mapper.updateUser(new User(2,"aaaa","bbbbb"));

        User user2 = mapper.queryUserById(2);
        System.out.println(user2);

        System.out.println(user==user2);

        sqlSession.close();
    }

我们可以发现，增删改查操作可能会改变原来的数据，所以必定会刷新缓存！

3.查询不同的Mapper.xml

4.手动清理缓存

 @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user = mapper.queryUserById(1);
        System.out.println(user);

        sqlSession.clearCache();//手动清理缓存

        User user2 = mapper.queryUserById(2);
        System.out.println(user2);

        System.out.println(user==user2);

        sqlSession.close();
    }

我们可以发现，手动清理缓存后，sql这次查询了2次

小结：

一级缓存默认是开启的，只在一次SqlSession中有效，也就是拿到连接到关闭连接这个区间段！

一缓存相当于就是一个map。

二级缓存

◆ 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
◆ 基于namespace级别的缓存，一个名称空间，对应一个二级缓存
工作机制
      ◆ 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中
      ◆ 如果会话关闭了，这个会员对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中
      ◆ 新的会话查询信息，就可以从二级缓存中获取内容
      ◆ 不同的mapper查询出的数据会放在自己对应的缓存（map）中

一级缓存开启（SqlSession级别的缓存，也称为本地缓存）

◆ 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
◆ 为了提高可扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来定义二级缓存。

步骤：

1.开启全局缓存

        <!--显示的开启全局缓存-->
        <setting name="cacheEnabled" value="true"/>

2.在Mapper.xml中使用二级缓存

    <!--在当前Mapper.xml中使用二级缓存-->
    <cache/>

    <!--在查询语句中也能使用二级缓存控制-->
    <select id="queryUserById" resultType="user" useCache="true">
        select * from user where id = #{id}
    </select>

3.也可以自定义参数

    <!--在当前Mapper.xml中使用二级缓存-->
    <!--readOnly为True时是读相同实例, false时是读拷贝值，相对安全，所以会出现比较时出现false
-->
    <!--
    eviction="FIFO" 使用FIFO输出策略
    flushInterval="60000" 每隔60秒刷新缓存
    size="512" 最多只能存512个缓存
    readOnly="true" 是否只读
    -->
    <cache eviction="FIFO"
    flushInterval="60000"
    size="512"
    readOnly="true"/>

小结：

◆ 问题：我们需要将实体类序列化，否则就会报错
◆ 只要开启了二级缓存，在同一个Mapper下就有效
◆ 所有的数据都会放在一级缓存中
◆ 只有当前会话提交，或者关闭的时候，才会提交到二级缓存中

缓存原理

自定义缓存(Ehcache)

Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点。

1.要在程序中使用，需要导包：

<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.1</version>
</dependency>

2.在mapper中指定使用我们的ehcache缓存实现

<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

Ehcache 中ehcache.xml 配置详解和示例：

     <?xml version="1.0" encoding="UTF-8"?>
    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
             updateCheck="false">
    
        <!--持久化磁盘路径-->
        <diskStore path="java.io.tmpdir"/>
        
        <!--默认缓存设置-->
        <defaultCache maxElementsInMemory="1000"
                       eternal="false"
                       timeToIdleSeconds="3600"
                       timeToLiveSeconds="0"
                       overflowToDisk="true"
                       maxElementsOnDisk="10000"
                       diskPersistent="false"
                       diskExpiryThreadIntervalSeconds="120"
                       memoryStoreEvictionPolicy="FIFO"
        />
        　
        <!--
            <cache     name 缓存名唯一标识
                       maxElementsInMemory="1000" 内存中最大缓存对象数
                       eternal="false" 是否永久缓存
                       timeToIdleSeconds="3600" 缓存清除时间 默认是0 即永不过期
                       timeToLiveSeconds="0" 缓存存活时间 默认是0 即永不过期
                       overflowToDisk="true" 缓存对象达到最大数后，将其写入硬盘
                       maxElementsOnDisk="10000"  磁盘最大缓存数
                       diskPersistent="false" 磁盘持久化
                       diskExpiryThreadIntervalSeconds="120" 磁盘缓存的清理线程运行间隔
                       memoryStoreEvictionPolicy="FIFO" 缓存清空策略
                       FIFO 先进先出
                       LFU  less frequently used  最少使用
                       LRU  least recently used 最近最少使用
        />
        -->

        <cache name="testCache"
               maxEntriesLocalHeap="2000"
               eternal="false"
               timeToIdleSeconds="3600"
               timeToLiveSeconds="0"
               overflowToDisk="false"
               statistics="true"
               memoryStoreEvictionPolicy="FIFO">
        </cache>
    </ehcache>

使用方法：

用法

    import net.sf.ehcache.Cache;
    import net.sf.ehcache.CacheManager;
    import net.sf.ehcache.Element;
    import java.net.URL;
    
    public class EhcacheUtil {
    
        private static final String default_path = "/ehcache.xml";
    
        private URL url;
    
        private CacheManager manager;
    
        public CacheManager getManager() {
            return manager;
        }
    
        public void setManager(CacheManager manager) {
            this.manager = manager;
        }
    
        private EhcacheUtil() {
            url = getClass().getResource(default_path);
            manager = CacheManager.create(url);
            manager.addCacheIfAbsent("default_cache");
        }
    
    
        private EhcacheUtil(String path) {
            url = getClass().getResource(path);
            System.out.println(url.getPath());
            manager = CacheManager.create(url);
            manager.addCacheIfAbsent("default_cache");
        }
    
        public void put(String cacheName, String key, Object value) {
            Cache cache = manager.getCache(cacheName);
            Element element = new Element(key, value);
            cache.put(element);
        }
    
        public Object get(String cacheName, String key) {
            Cache cache = manager.getCache(cacheName);
            Element element = cache.get(key);
            return element == null ? null : element.getObjectValue();
        }
    
        public Cache get(String cacheName) {
            return manager.getCache(cacheName);
        }
    
        public void remove(String cacheName, String key) {
    
            Cache cache = manager.getCache(cacheName);
            cache.remove(key);
        }
    
        public static void main(String[] args){
            EhcacheUtil ehcacheUtil = new EhcacheUtil("/ehcache.xml");
            ehcacheUtil.put("default_cache","key","value");
            String result = (String)ehcacheUtil.get("default_cache","key");
            System.out.println(result);
            //System.out.println(EhcacheUtil.class.getResource(""));
       }
    }

你可能感兴趣的:(JAVA框架第三阶段笔记,#,Mybatis框架,java,mybatis,mysql)

Java设计模式之解释器模式飞翔中文网 java 设计模式
概念解释器模式是一种行为型设计模式，用于定义一种语言的语法规则，并提供解释器来解释该语言中的表达式。作用其核心作用是将复杂的语法分解为简单的语法单元，通过递归组合的方式构建抽象语法树（AST），最终由解释器逐层解释执行。场景1.需要解释特定领域的语言：如数学公式、正则表达式、SQL查询等。2.语法相对简单且稳定：若语法频繁变化或过于复杂，建议使用解析器生成工具（如ANTLR）。3.需要灵活扩展语法
MyBatis StatementHandler是如何创建 Statement 对象的？如何执行 SQL 语句？冰糖心书房 Mybatis 源码系列 2025 Java面试系列 mybatis sql 数据库
在MyBatis中，StatementHandler负责创建Statement对象并执行SQL语句。以下是其具体流程：1.StatementHandler.prepare()方法：创建JDBCStatement对象StatementHandler.prepare(Connectionconnection,IntegertransactionTimeout)方法是核心方法，负责基于MappedSta
深入理解 Java 内存模型（JMM）：原理、可见性与并发控制全栈探索者chen java java 开发语言缓存程序人生数据库 JMM 内存
深入理解Java内存模型（JMM）：原理、可见性与并发控制1.引言在多线程编程中，内存可见性、指令重排序和线程同步是开发者必须理解的核心概念。Java内存模型（JMM，JavaMemoryModel）定义了一组规则，确保Java程序在并发环境下的线程安全性和一致性。本文将深入剖析JMM的原理，并通过代码示例展示如何正确控制并发。2.什么是Java内存模型（JMM）？Java内存模型（JMM）是Ja
Java 并发编程实战：深入理解线程池的核心原理与最佳实践全栈探索者chen java java 服务器开发语言性能优化缓存 node.js 数据库
Java并发编程实战：深入理解线程池的核心原理与最佳实践1.为什么需要线程池？在Java并发编程中，直接创建和管理线程的成本较高，频繁创建线程会带来性能开销和资源浪费。线程池（ThreadPool）的作用：降低线程创建和销毁的开销，提高系统响应速度。提高系统吞吐量，充分利用CPU资源。避免资源耗尽，限制最大线程数，防止OOM（内存溢出）。支持任务排队，确保任务按照一定规则执行。2.线程池的核心组成
Visual Studio Code官网下载地址及使用技巧（含常用的拓展插件推荐） ITCTCSDN vscode ide 编辑器
VisualStudioCode（简称“VSCode”）是Microsoft于2015年4月发布的可运行于MacOS、Windows和Linux之上的跨平台源代码编辑器，它具有对JavaScript，TypeScript和Node.js的内置支持，并具有丰富的其他语言（例如C++，C＃，Java，Python，PHP，Go）和运行时（例如.NET和Unity）扩展的生态系统。VisualStudi
利用AI与MySQL提升工业物联网健康监测的智慧水平——构建预测性维护的新纪元墨夶数据库学习资料1 人工智能 mysql 物联网
在工业4.0和智能制造的大背景下，如何确保生产设备的高效稳定运行成为企业竞争力的核心要素之一。传统的事后维修方式已经难以满足现代制造业的需求，而基于人工智能（AI）的预测性维护系统则为这一挑战提供了全新的解决方案。今天，我们将深入探讨如何结合AI技术和MySQL数据库，打造一个智能、高效的工业物联网（IIoT）健康监测平台，助力企业在激烈的市场竞争中脱颖而出。一、为什么选择AI+MySQL？1.A
MySQL中基于机器学习的自适应缓存热点识别优化策略——开启数据库性能新纪元墨夶数据库学习资料1 数据库 mysql 机器学习
在数据驱动的世界里，数据库的性能直接影响到整个应用系统的响应速度和用户体验。随着业务量的增长和技术的发展，传统的缓存机制逐渐暴露出局限性。如何更智能地识别并利用热点数据进行缓存优化，成为提升数据库性能的关键所在。今天，我们将深入探讨一种创新的方法——基于机器学习的自适应缓存热点识别优化策略，并分享其在MySQL中的具体实现方案。为什么选择机器学习？‍传统上，开发者们依赖于手动配置或预设规则来决定哪
数据安全新纪元——多方安全计算与MySQL结合的隐私预算管理深度解析墨夶数据库学习资料1 安全 mysql android
在当今数字化时代，数据已成为企业最宝贵的资产之一。然而，随着数据泄露事件频发，如何确保数据的安全性和隐私性成为了亟待解决的问题。传统的加密技术虽然能在一定程度上保护静态数据，但在动态数据分析过程中却显得力不从心。为了解决这一难题，隐私计算作为一种新兴的技术应运而生，它允许在不解密原始数据的前提下进行有效的计算和分析。本文将深入探讨如何利用多方安全计算（MPC）与关系型数据库MySQL相结合的方式实
Java 24 正式发布：AI 开发与后量子安全引领企业级编程革命程序猿小白菜后端java生态圈 java 人工智能安全
摘要2025年3月18日，Oracle正式发布Java24（OracleJDK24），这是Java诞生30周年之际的重要版本更新。新版本聚焦AI开发支持、后量子安全加密、性能优化和开发效率提升，提供20余项新特性及数千项改进，为企业级应用开发注入全新动力。一、语言特性：代码简洁性与模式匹配增强Java24在语法层面进一步简化代码逻辑，提升开发效率：JEP488：原始类型模式匹配（第二次预览）支持在
算法笔记——前缀树、贪心算法（更新ing....... 不吃香菜的码农左神算法笔记算法数据结构贪心算法 leetcode 堆栈
前缀树、贪心算法一、前缀树1.什么是前缀树2.如何生成前缀树二、贪心算法1.拼接字符串2.金条问题3.项目会议时间问题4.项目收益最大化4.随时获得数据流的中位数一、前缀树1.什么是前缀树前缀树一般指字典树这是指一种结构而不是一类题（注意信息是在树的路上）典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查
什么是Spring Boot？它在Java后端开发中的作用是什么？破碎的天堂鸟学习教程 java spring boot 数据库
什么是SpringBoot？SpringBoot是由Pivotal团队开发的一个基于Spring框架的快速开发框架，旨在简化Spring应用的初始搭建和开发流程。其核心理念是“约定优于配置”（ConventionoverConfiguration），通过默认配置和自动化机制，使开发者能够快速构建独立的、生产级别的应用程序。以下是其核心定义与特点：基于Spring的扩展与优化SpringBoot并非
庖丁解java(一篇文章学java) 庖丁解java java 开发语言 spring boot 后端
(大家不用收藏这篇文章,因为这篇文章会经常更新,也就是删除后重发)一篇文章学java,这是我滴一个执念...当然,真一篇文章就写完java基础,java架构,java业务实现,java业务扩展,根本不可能.所以,这篇文章,就是一个索引,索什么呢?请看下文...关于决定开始写博文的介绍(一切故事的起点源于这一次反省)中小技术公司的软扩展(微服务扩展是否有必要?)-CSDN博客SpringCloud(
ts之变量声明以及语法细节，ts小白初学ing 菥菥爱嘻嘻小白学习ts typescript 前端
TypeScript用js编写的项目虽然开发很快，但是维护是成本很高，而且js不报错啊啊啊啊啊！！！以js为基础进行扩展的给变量赋予了类型语法、实战(ts+vue3)TypeScript是JavaScript的一个超集，支持ECMAScript6标准（ES6教程）。TypeScript由微软开发的自由和开源的编程语言，在JavaScript的基础上增加了静态类型检查的超集。TypeScript设计
Node.js 如何发布一个 NPM 包——详细教程还是鼠鼠 node.js npm 前端 node.js vscode
在本文中，我将带大家一步步学习如何创建并发布一个NPM包，帮助开发者理解整个流程，并能顺利将自己的JavaScript库发布到NPM上供他人使用。1.安装Node.js和npm在开始之前，请确保你的电脑上已经安装了Node.js和npm（Node.js自带npm）。你可以在终端（Windows用户请使用cmd或PowerShell）输入以下命令检查是否已安装：node-vnpm-v如果出现版本号，
docker创建的mysql没有配置文件_使用docker安装mysql, redis, kafka等各类服务 Gyrolt
前言大致说来,docker的作用如下绝大部分应用，开发者都可以通过dockerbuild创建镜像，通过dockerpush上传镜像，用户通过dockerpull下载镜像，用dockerrun运行应用。用户不需要再去关心如何搭建环境，如何安装，如何解决不同发行版的库冲突——而且通常不会需要消耗更多的硬件资源，不会明显降低性能。也就是实现了标准化、集装箱如果想要简单使用,可以看答主的这一片文章:番茄番
qt读书笔记 mmmcu2004 QT qt 读书 translation 工作 action
QWidget::setToolTip()用于为Widget设置相应的tip文本。同样，QAction::setToolTip()为Action设置相应的tip文本；若没有显式的为Action设置tip文本,Action会自动的使用actiontext。setStatusTip()，该函数为Widget和Action添加statustip。QWidget::setWhatsThis()QWhats
Qt学习之路学习笔记3 delphi863
1，文件对方框创建file对象，选择打开方式，打开后传递给QTextStream，读取，赋给QText显示，关闭文件。（QTextStream::readAll()直接读取文件所有内容，如果这个文件有100M，程序会立刻死掉）实际应用中，分段读入怎么处理？2、事件中的继承自QLabel的鼠标事件label->setMouseTracking(true);设置后才能允许就跟踪，否则需要点击一次，才跟
C# 技术使用笔记：Asp.Net Core MVC 中控制器 Controllers 中返回数据使用详解 caifox菜狐狸 C#技术使用笔记 c#笔记 asp.net core ViewResult JsonResult Redirect 控制器
本文将深入探讨ASP.NETCoreMVC控制器中返回数据的多种方式，从基础的ViewResult到灵活的IActionResult，再到强大的ActionResult，我们将逐一剖析它们的使用场景、优缺点以及最佳实践。通过丰富的代码示例和详细的解释，帮助读者全面掌握控制器返回数据的技巧，从而提升开发效率，构建更加健壮和高效的Web应用程序。无论你是初学者还是有一定经验的开发者，本文都将为你提供有
程序员晋升架构师实战指南甘苦人生职业规划职场和发展
以下是为程序员量身定制的晋升架构师实战指南，结合行业案例与可落地路径，助你完成技术跃迁：一、晋升路径拆解（从Code到Architecture）程序员→高级工程师核心任务：独立完成模块开发（需求分析+方案设计+编码实现）技术重点：掌握1-2门核心语言（如Java/Go）、熟悉主流框架（SpringCloud/Dubbo）案例：主导用户中心模块开发，通过缓存优化将接口响应时间从800ms降至150m
Linux 启动Jar脚本&&设置开机自启【超级详细】黑taoA linux jar python
Linux启动Jar脚本&&设置开机自启【超级详细】概要服务器开机自启服务重启脚本概要最近在Linux服务器中部署了一个项目（单机版），每次更新服务的时候需要用到好几个命令，停止服务，再重启，并且服务器突然重启后，还需要人工重启服务，非常繁琐，下面展示了两个脚本的写法。。服务器开机自启检查系统是否安装jdk；java-version查看jdk安装位置whereisjava编写脚本restart_y
包管理工具她的双马尾 JS javascript 包管理工具 npm yarn pnpm
JavaScript包管理工具对比：npm、yarn和pnpm1.npm1.1历史与背景npm（NodePackageManager）是Node.js的默认包管理工具，首次发布于2010年。它是JavaScript生态系统中最早的包管理工具，主要用于管理和共享JavaScript模块。目前，npm拥有全球最大的JavaScript包注册中心（npmregistry），包含数百万个开源包。1.2核心
PV操作(Java代码)进程同步实战指南 Cloud_. java 开发语言操作系统并发
引言在Java并发编程中，资源同步如同精密仪器的齿轮咬合，任何偏差都可能导致系统崩溃。本文将以Java视角解析经典PV操作原理，通过真实可运行的代码示例，带你掌握线程同步的底层实现逻辑。一、Java信号量实现机制1.1Semaphore类解析importjava.util.concurrent.Semaphore;//创建包含5个许可的信号量（相当于计数信号量）Semaphoresemaphore
开发语言漫谈-groovy 大道不孤,众行致远技术杂谈开发语言
groovy是一门脚本语言，在前期的脚本语言中简单介绍了下。现在再深入介绍下，因为它是本平台上选用的脚本语言。所谓脚本语言就是不用编译，直接执行。这种特色非常适合做嵌入编程，即编即用。我们知道平台后台的业务开发语言是Java，开发人员都熟悉Java。那么使用groovy就是自然而然的事情，因为groovy最大特点就是和Java兼容。然后做了最有意义的改造：1、可以解释执行；2、增加动态类型。发明人
java:实现设置窗体背景颜色为淡蓝色（附带源码） Katie。 Java 实战项目 java 信息可视化开发语言
一、项目简介在桌面应用开发中，窗体背景颜色作为界面设计的重要组成部分，不仅影响整体美观，还能传递特定的情感和品牌信息。本项目旨在使用JavaSwing简单实现将窗体背景颜色设置为淡蓝色效果。该示例展示了如何创建一个基本的JFrame，并通过调用其内容面板的setBackground()方法，设置背景颜色为淡蓝色（RGB值173,216,230）。通过本项目，初学者可以了解Swing基本组件的使用方
前端实例：轮播图效果 2301_81535770 前端
利用HTML、CSS和JavaScript实现轮播图效果。一、轮播图原理：通过给窗口设置position属性和overflow属性，使得超出窗口范围的部分被隐藏，表面可见范围只包含窗口，但实际上其内部空间很大；调整胶卷相对于窗口的位置，使得整个胶卷向左移动；调用JS中的定时器，实现轮播效果。流程图如下：二、实现自动切换效果1、HTML搭建基础框架分为图片展示窗口和上下页切换按键两部分>2、CSS设
Orange 单体架构 - 快速启动 mmd0308 Orange 开源项目架构开源
1后端服务1.1基础设施组件说明版本MySQLMySQL数据库服务5.7/8+JavaJava17redis-stackRedis向量数据库最新版本Node安装Node22.11.0+1.2orange-dependencies-parent项目Maven依赖版本管理1.2.1项目克隆GitHubgitclonehttps://github.com/hengzq/orange-dependenci
过滤器Filter " 微笑 spring
过滤器Filter1.快速入门什么是Filter？Filter表示过滤器，是JavaWeb三大组件(Servlet、Filter、Listener)之一。过滤器可以把对资源的请求拦截下来，从而实现一些特殊的功能使用了过滤器之后，要想访问web服务器上的资源，必须先经过滤器，过滤器处理完毕之后，才可以访问对应的资源。过滤器一般完成一些通用的操作，比如：登录校验、统一编码处理、敏感字符处理等。下面我们
深夜惊魂：当监控告警“撒谎”时，SRE 如何逆风翻盘？ YAMLMaster kubernetes 运维开发 devops 容器云原生
Yorkshire,England引言我们这一篇也是含金量十足，如果面试官让你说个你处理过的比较有意思的案例，可以跟他讲讲，让他也见见世面。好吧，我们直接开始，最后有相关的群，有兴趣可以加入。开始一、故障场景深度还原时间：2025年1月3日02:00（GMT+8）环境：•数据库集群：MySQL8.0.35，通过KubeBlocks部署（3节点，跨AZ）•监控架构：•Prometheus-Opera
【MyBatisPlus】MyBatisPlus介绍与使用 web_15534274656 面试学习路线阿里巴巴 java
【MyBatisPlus】MyBatisPlus介绍与使用文章目录【MyBatisPlus】MyBatisPlus介绍与使用1、什么MyBatisPlus2、MyBatisPlus的CRUD操作3、MyBatisPlus分页使用1、什么MyBatisPlusMyBatisPlus（简称MP）是基于MyBatis框架基础上开发的增强型工具，旨在简化开发、提高效率官网：https://baomidou
k8s运维设置Pod实现JVM内存根据容器内存动态调整风行無痕 K8S kubernetes jvm 容器
一、实现方式推荐方案：利用JVM容器感知特性，按比例动态分配。适用场景‌：动态根据Pod内存限制自动分配堆内存，无需硬编码参数Java要求：Java8u191+或Java11+Java8u191+或Java11+支持通过-XX:InitialRAMPercentage替代-Xms，根据容器内存限制自动计算堆内存。在容器环境变量中配置-XX:MaxRAMPercentage=75.0，使JVM根据容
web报表工具FineReport常见的数据集报错错误代码和解释老A不折腾 web报表 finereport 代码可视化工具
在使用finereport制作报表，若预览发生错误，很多朋友便手忙脚乱不知所措了，其实没什么，只要看懂报错代码和含义，可以很快的排除错误，这里我就分享一下finereport的数据集报错错误代码和解释，如果有说的不准确的地方，也请各位小伙伴纠正一下。 NS-war-remote=错误代码\:1117 压缩部署不支持远程设计 NS_LayerReport_MultiDs=错误代码
Java的WeakReference与WeakHashMap bylijinnan java 弱引用
首先看看 WeakReference wiki 上 Weak reference 的一个例子： public class ReferenceTest { public static void main(String[] args) throws InterruptedException { WeakReference r = new Wea
Linux——（hostname）主机名与ip的映射 eksliang linux hostname
一、什么是主机名无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。但IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。域名类型 linuxsir.org 这样的；主机名是用于什么的呢？答：在一个局域网中，每台机器都有一个主
oracle 常用技巧 18289753290
oracle常用技巧 ①复制表结构和数据 create table temp_clientloginUser as select distinct userid from tbusrtloginlog ②仅复制数据如果表结构一样 insert into mytable select * &nb
使用c3p0数据库连接池时出现com.mchange.v2.resourcepool.TimeoutException 酷的飞上天空 exception
有一个线上环境使用的是c3p0数据库，为外部提供接口服务。最近访问压力增大后台tomcat的日志里面频繁出现 com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.v2.resourcepool.BasicResou
IT系统分析师如何学习大数据蓝儿唯美大数据
我是一名从事大数据项目的IT系统分析师。在深入这个项目前需要了解些什么呢？学习大数据的最佳方法就是先从了解信息系统是如何工作着手，尤其是数据库和基础设施。同样在开始前还需要了解大数据工具，如Cloudera、Hadoop、Spark、Hive、Pig、Flume、Sqoop与Mesos。系统分析师需要明白如何组织、管理和保护数据。在市面上有几十款数据管理产品可以用于管理数据。你的大数据数据库可能
spring学习——简介 a-john spring
Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只能由EJB完成的事情。然而Spring的用途不仅限于服务器端的开发，从简单性，可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。其主要特征是依赖注入、AOP、持久化、事务、SpringMVC以及Acegi Security 为了降低Java开发的复杂性，
自定义颜色的xml文件 aijuans xml
<?xml version="1.0" encoding="utf-8"?> <resources> <color name="white">#FFFFFF</color> <color name="black">#000000</color> &
运营到底是做什么的？ aoyouzi 运营到底是做什么的？
文章来源：夏叔叔（微信号：woshixiashushu），欢迎大家关注！很久没有动笔写点东西，近些日子，由于爱狗团产品上线，不断面试，经常会被问道一个问题。问：爱狗团的运营主要做什么？答：带着用户一起嗨。为什么是带着用户玩起来呢？究竟什么是运营？运营到底是做什么的？那么，我们先来回答一个更简单的问题——互联网公司对运营考核什么？以爱狗团为例，绝大部分的移动互联网公司，对运营部门的考核分为三块——用
js面向对象类和对象百合不是茶 js 面向对象函数创建类和对象
接触js已经有几个月了,但是对js的面向对象的一些概念根本就是模糊的,js是一种面向对象的语言但又不像java一样有class,js不是严格的面向对象语言 ,js在java web开发的地位和java不相上下 ,其中web的数据的反馈现在主流的使用json,json的语法和js的类和属性的创建相似下面介绍一些js的类和对象的创建的技术一:类和对
web.xml之资源管理对象配置 resource-env-ref bijian1013 java web.xml servlet
resource-env-ref元素来指定对管理对象的servlet引用的声明，该对象与servlet环境中的资源相关联 <resource-env-ref> <resource-env-ref-name>资源名</resource-env-ref-name> <resource-env-ref-type>查找资源时返回的资源类
Create a composite component with a custom namespace sunjing
https://weblogs.java.net/blog/mriem/archive/2013/11/22/jsf-tip-45-create-composite-component-custom-namespace When you developed a composite component the namespace you would be seeing would
【MongoDB学习笔记十二】Mongo副本集服务器角色之Arbiter bit1129 mongodb
一、复本集为什么要加入Arbiter这个角色回答这个问题，要从复本集的存活条件和Aribter服务器的特性两方面来说。什么是Artiber？ An arbiter does not have a copy of data set and cannot become a primary. Replica sets may have arbiters to add a
Javascript开发笔记白糖_ JavaScript
获取iframe内的元素通常我们使用window.frames["frameId"].document.getElementById("divId").innerHTML这样的形式来获取iframe内的元素，这种写法在IE、safari、chrome下都是通过的，唯独在fireforx下不通过。其实jquery的contents方法提供了对if
Web浏览器Chrome打开一段时间后，运行alert无效 bozch Web chorme alert 无效
今天在开发的时候，突然间发现alert在chrome浏览器就没法弹出了，很是怪异。试了试其他浏览器，发现都是没有问题的。开始想以为是chorme浏览器有啥机制导致的，就开始尝试各种代码让alert出来。尝试结果是仍然没有显示出来。这样开发的结果，如果客户在使用的时候没有提示，那会带来致命的体验。哎，没啥办法了就关闭浏览器重启。结果就好了，这也太怪异了。难道是cho
编程之美-高效地安排会议图着色问题贪心算法 bylijinnan 编程之美
import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Random; public class GraphColoringProblem { /**编程之美高效地安排会议图着色问题贪心算法 * 假设要用很多个教室对一组
机器学习相关概念和开发工具 chenbowen00 算法 matlab 机器学习
基本概念：机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。开发工具 M
[宇宙经济学]关于在太空建立永久定居点的可能性 comsci 经济
大家都知道,地球上的房地产都比较昂贵,而且土地证经常会因为新的政府的意志而变幻文本格式........ 所以,在地球议会尚不具有在太空行使法律和权力的力量之前,我们外太阳系统的友好联盟可以考虑在地月系的某些引力平衡点上面,修建规模较大的定居点
oracle 11g database control 证书错误 daizj oracle 证书错误 oracle 11G 安装
oracle 11g database control 证书错误 win7 安装完oracle11后打开 Database control 后，会打开em管理页面，提示证书错误，点“继续浏览此网站”，还是会继续停留在证书错误页面解决办法：是 KB2661254 这个更新补丁引起的，它限制了 RSA 密钥位长度少于 1024 位的证书的使用。具体可以看微软官方公告：
Java I/O之用FilenameFilter实现根据文件扩展名删除文件游其是你 FilenameFilter
在Java中，你可以通过实现FilenameFilter类并重写accept(File dir, String name) 方法实现文件过滤功能。在这个例子中，我们向你展示在“c:\\folder”路径下列出所有“.txt”格式的文件并删除。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
C语言数组的简单以及一维数组的简单排序算法示例，二维数组简单示例 dcj3sjt126com c array
# include <stdio.h> int main(void) { int a[5] = {1, 2, 3, 4, 5}; //a 是数组的名字 5是表示数组元素的个数，并且这五个元素分别用a[0], a[1]...a[4] int i; for (i=0; i<5; ++i) printf("%d\n",
PRIMARY, INDEX, UNIQUE 这3种是一类 PRIMARY 主键。就是唯一且不能为空。 INDEX 索引，普通的 UNIQUE 唯一索引 dcj3sjt126com primary
PRIMARY, INDEX, UNIQUE 这3种是一类PRIMARY 主键。就是唯一且不能为空。INDEX 索引，普通的UNIQUE 唯一索引。不允许有重复。FULLTEXT 是全文索引，用于在一篇文章中，检索文本信息的。举个例子来说，比如你在为某商场做一个会员卡的系统。这个系统有一个会员表有下列字段：会员编号 INT会员姓名
java集合辅助类 Collections、Arrays shuizhaosi888 Collections Arrays HashCode
Arrays、Collections 1 ）数组集合之间转换 public static <T> List<T> asList(T... a) { return new ArrayList<>(a); } a）Arrays.asL
Spring Security（10）——退出登录logout 234390216 logout Spring Security 退出登录 logout-url LogoutFilter
要实现退出登录的功能我们需要在http元素下定义logout元素，这样Spring Security将自动为我们添加用于处理退出登录的过滤器LogoutFilter到FilterChain。当我们指定了http元素的auto-config属性为true时logout定义是会自动配置的，此时我们默认退出登录的URL为“/j_spring_secu
透过源码学前端之 Backbone 三 Model 逐行分析JS源代码 backbone 源码分析 js学习
Backbone 分析第三部分 Model 概述： Model 提供了数据存储，将数据以JSON的形式保存在 Model的 attributes里，但重点功能在于其提供了一套功能强大，使用简单的存、取、删、改数据方法，并在不同的操作里加了相应的监听事件，如每次修改添加里都会触发 change，这在据模型变动来修改视图时很常用，并且与collection建立了关联。
SpringMVC源码总结（七）mvc:annotation-driven中的HttpMessageConverter 乒乓狂魔 springMVC
这一篇文章主要介绍下HttpMessageConverter整个注册过程包含自定义的HttpMessageConverter，然后对一些HttpMessageConverter进行具体介绍。 HttpMessageConverter接口介绍： public interface HttpMessageConverter<T> { /** * Indicate
分布式基础知识和算法理论 bluky999 算法 zookeeper 分布式一致性哈希 paxos
分布式基础知识和算法理论 BY [email protected] 本文永久链接：http://nodex.iteye.com/blog/2103218 在大数据的背景下，不管是做存储，做搜索，做数据分析，或者做产品或服务本身，面向互联网和移动互联网用户，已经不可避免地要面对分布式环境。笔者在此收录一些分布式相关的基础知识和算法理论介绍，在完善自我知识体系的同
Android Studio的.gitignore以及gitignore无效的解决 bell0901 android gitignore
　　github上.gitignore模板合集，里面有各种.gitignore ： https://github.com/github/gitignore 　　自己用的Android Studio下项目的.gitignore文件，对github上的android.gitignore添加了　　　　　　# OSX files　　　　　　//mac os下　　　　　　.DS_Store
成为高级程序员的10个步骤 tomcat_oracle 编程
What 软件工程师的职业生涯要历经以下几个阶段：初级、中级，最后才是高级。这篇文章主要是讲如何通过 10 个步骤助你成为一名高级软件工程师。 Why 得到更多的报酬！因为你的薪水会随着你水平的提高而增加提升你的职业生涯。成为了高级软件工程师之后，就可以朝着架构师、团队负责人、CTO 等职位前进历经更大的挑战。随着你的成长，各种影响力也会提高。
mongdb在linux下的安装 xtuhcy mongodb linux
一、查询linux版本号： lsb_release -a LSB Version: :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noa

JAVA MyBatis框架(超详细教程)

MyBatis 框架

一、MyBatis 框架概述：

1.是什么？

2.应用的优势？

3.如何获得mybatis？

Github链接:https://github.com/mybatis/mybatis-3

maven仓库

4.什么是持久层？

为什么要持久化？

5.什么是持久层？

小结：

1)重难点?

2)FAQ

二、第一个mybatis程序

第一步：搭建环境

1 搭建数据库

1.2 新建项目

1.3 删除src 导入依赖

1.4 创建模块

第二步：创建模块

2.编写mybatis的核心配置文件

2.1.编写mybatis工具类

第三步：编写(实体类 和 Dao接口)

3.1 实体类

3.2 Dao接口

3.3 接口实现类

3.4 @Test 测试

问题一

问题二：

可能会遇到的问题：

三、 CRUD 增删改查

1.namespace（命名空间）

2.select(查询)

3. insert(增加)

4.update(修改)

5.delete(删除)

分析错误

Map优化

模糊查询

四、配置解析

4.1.新建一个项目mybatis02

4.2. 环境配置 environments

4.3. 属性 properties

4.4. 类型别名 typeAliases

4.5. 设置 Settings

4.6. 其他配置(简单了解即可)

4.7. 映射器 mappers

4.8. 作用域和生命周期

五、ResultMap结果集映射

解决属性名和字段名不一致的问题

解决方法：

5.1.起别名：

5.2.resultMap(结果集映射)

六、日志

6.1日志工厂

STDOUT_LOGGING标准日志输出

6.2 Log4j

1.先导入log4j的包

2.log4j.properties

3.配置settings为log4j实现

4.测试运行

Log4j简单使用

七、分页

思考：

7.1 使用Limit分页

使用MyBatis实现分页，核心SQL

1.接口

2.Mapper.xml

3.测试

7.2RowBounds分页(理解就好，基本不用)

7.3 分页插件(了解就好，需要的时候在查看文档使用)

八、注解开发

8.1、面向接口编程

关于接口的理解

接口应有两类:

三个面向区别

8.2 使用注解开发

1.新建一个mybatis-04 Maven项目

2.准备项目的基本架构

第三步：编写(实体类和 Dao接口)

2.在需要使用的地方使用include标签即可