Maven&&Mybatis

最新推荐文章于 2024-05-15 16:59:55 发布

Gold 大龙

最新推荐文章于 2024-05-15 16:59:55 发布

阅读量267

点赞数

分类专栏： Java SE 文章标签： maven intellij-idea java

本文链接：https://blog.csdn.net/lorikiller/article/details/125020764

版权

Java SE 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Maven&&Mybatis

Maven

1.1 概念

项目管理工具：jar包的管理与项目的构建通过pom.xml 核心文件来配置

1.2 私服与仓库配置

仓库的配置只需要修改一个配置文件即可：maven安装目录下面的主配置文件conf/settings.xml

本地仓库

解压仓库的压缩包到某个目录，然后在settings.xml中配置如下内容：

解压我分享的仓库到下面配置的位置（本地仓库）中

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
    <!-- localRepository
     | The path to the local repository maven will use to store artifacts.
	 | 指定本地电脑保存jar包的路径，也就是本地仓库的路径
     |
     | Default: ${user.home}/.m2/repository
     | 如未指定，默认使用 用户目录/.m2/repository，该位置一般是在C盘，不推荐使用。
		重点是下面的内容
       -->
  <localRepository>D:\Develop\Repository\Maven_Repository</localRepository>

注：

配置好之后，在idea整合maven时，需要重新建立索引，才能让idea有提示。（仅限于先使用idea集成了maven，后解压更新了仓库的情况）。

中央仓库镜像

配置阿里云对中央仓库的镜像，下载速度快。

注意放在被注释的mirrors下面，小心层级关系

<mirrors>
    <!-- 私服的配置方式一：所有的项目默认连接私服获取jar包，连接失败之后再连aliyun -->
    <mirror>
        <!-- 本镜像的id，与这里配置的其他镜像id不一样即可 -->
        <id>nexus</id>
        <!--  central表示镜像的是中央仓库 -->
        <mirrorOf>*</mirrorOf>
        <!-- 镜像路径，固定不变 -->
        <url>http://192.168.21.200:8081/repository/maven-public/</url>
    </mirror>   
    <mirror>
        <!-- 本镜像的id，与这里配置的其他镜像id不一样即可 -->
        <id>alimaven</id>
        <!--  central表示镜像的是中央仓库 -->
        <mirrorOf>central</mirrorOf>
        <!-- 名称，可以省略 -->
        <name>aliyun maven</name>
        <!-- 镜像路径，固定不变 -->
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    </mirror>   
</mirrors>

私服的配置方式二：某个项目的pom.xml文件配置

在每个/某个模块的pom.xml文件中配置如下内容，粘贴在标签下即可

<!-- 方式二：为当前模块配置私服，本内容复制到pom.xml的project标签下 -->
<repositories>
    <repository>
        <!-- 依赖仓库id，不可重复。repositories可以配置多个仓库，如果ID重复后面配置会覆盖之前的配置 -->
        <id>dependencies_Repositories</id>
        <!-- 私服仓库地址，即nexus仓库组的地址 -->
        <url>http://192.168.21.200:8081/repository/maven-public/</url>

        <!-- 是否下载releases构件 -->
        <releases>
            <enabled>true</enabled>
        </releases>

        <!-- 是否下载snapshots构件 -->
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>
<!-- 配置插件从私服下载 -->
<pluginRepositories>
    <pluginRepository>
        <id>plugins_Repositories</id>
        <url>http://192.168.21.200:8081/repository/maven-public/</url>
        <!-- 是否下载release版本构件 -->
        <releases>
            <enabled>true</enabled>
        </releases>
        <!-- 是否下载snapshots版本构件 -->
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </pluginRepository>
</pluginRepositories>

Mybatis入门

2.1作用

框架：一个半成品的软件，用于简化代码 sql需要我们自己编写，自己优化sql，可定制性强，效率高
Mybatis是一个数据持久层（DAO）框架，封装共性内容让使用者只关注SQL本身。结合了ORM思想，是一个ORM半自动的框架。
是一个数据持久层（DAO）框架，封装共性内容让使用者只关注SQL本身。结合了ORM思想，是一个ORM半自动的框架。
使用Mybatis之后，我们只需要定义一个**Dao层接口**+存储SQL的配置文件（Mybatis映射配置文件）+ Mybatis核心配置文件，就可以完成Dao层内容。
使用步骤：导包+配置+代码
与JDBC的比较
- ~~注册驱动，设置连接参数~~
- ~~获取连接~~
- 获取执行对象
- 设置SQL参数并执行SQL语句
- 封装结果集并封装成实体对象
- ~~释放资源~~

Mybatis解决方案

连接复用：使用数据库连接池初始化并管理连接
解耦：将SQL语句和设置到SQL中的参数抽取到xml配置文件中
自动封装：通过反射内省等技术，实现查询结果集字段与实体属性自动映射并赋值

2.2 IDEA中进行Mybatis的配置以及使用

2.2.1 创建Model

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q8WbafRU-1653730250781)(C:\Users\22854\AppData\Roaming\Typora\typora-user-images\image-20220512113828701.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R8V11L5n-1653730250782)(C:\Users\22854\AppData\Roaming\Typora\typora-user-images\image-20220512113802818.png)]
在java中放java代码
在resources中放xml文件
在test中放测试代码

2.2 pom.xml中依赖配置

我们要用到数据库连
连接 mybatis驱动连接 mysq驱动 l，单元测试功能 juint ，日志功能 (有三个) slf4j-api,logback-classic,logback-core,为当前模块配置私服
在dependcies标签中添加多个dependcy
日志美化
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mFNJwruT-1653730250783)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512114643583.png)]
- 在resources下添加logback.xml代码如下下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>

        <!-- mysql数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>

        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <!--<scope>test</scope>-->
        </dependency>

        <!-- logback -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.20</version>
        </dependency>
        <!-- 添加logback-classic依赖 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- 添加logback-core依赖 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- lombok 编译的时候-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <repositories>
        <repository>
            <!-- 依赖仓库id，不可重复。repositories可以配置多个仓库，如果ID重复后面配置会覆盖之前的配置 -->
            <id>dependencies_Repositories</id>
            <!-- 私服仓库地址，即nexus仓库组的地址 -->
            <url>http://192.168.21.200:8081/repository/maven-public/</url>

            <!-- 是否下载releases构件 -->
            <releases>
                <enabled>true</enabled>
            </releases>

            <!-- 是否下载snapshots构件 -->
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>
    <!-- 配置插件从私服下载 -->
    <pluginRepositories>
        <pluginRepository>
            <id>plugins_Repositories</id>
            <url>http://192.168.21.200:8081/repository/maven-public/</url>
            <!-- 是否下载release版本构件 -->
            <releases>
                <enabled>true</enabled>
            </releases>
            <!-- 是否下载snapshots版本构件 -->
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>


</project>

logback.xml代码

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--
        CONSOLE ：表示当前的日志信息是可以输出到控制台的。
    -->
    <appender name="Console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>[%level]  %cyan([%thread]) %boldGreen(%logger{15}) - %msg %n</pattern>
        </encoder>
    </appender>

    <logger name="com.itheima" level="DEBUG" additivity="false">
        <appender-ref ref="Console"/>
    </logger>


    <!--
      level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF
     ， 默认debug
      <root>可以包含零个或多个<appender-ref>元素，标识这个输出位置将会被本日志级别控制。
      -->
    <root level="DEBUG">
        <appender-ref ref="Console"/>
    </root>
</configuration>

2.3核心配置文件mybatis-config的配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9Ijmu3su-1653730250783)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512115320965.png)]

在resource中添加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>
    
  <environments default="development">
    <environment id="development">
      <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>
     <!-- 加载映射配置文件，xxMapper，本质上就是之前学习的xxxDao -->   
  <mappers>
    <!-- -->
  </mappers>
    
    
</configuration>

需要对其进行修改
前四行是配置代码无需修改
只需配置数据库连接四要素即可
- <property name="driver" value="${driver}"/>需要写成
  - ```
  ` <property name="driver" value="com.mysql.jdbc.Driver"/>`表示连接l数据库类型是mysq
```
- <property name="url" value="${url}"/>表示连接的数据库的名称，我这里连接db1
  - ```
  `<property name="url" value="jdbc:mysql:///db1?useSSl=false"/>` `useSSl=false`是拒绝一个提醒
```
- <property name="username" value="${username}"/> <property name="password" value="${password}"/>是mysql的账号和密码
- ```
<property name="username" value="root"/>
<property name="password" value="1234"/>
```
<mappers> 是这里先不填写

2.4 数据提供

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Oin4nZU1-1653730250784)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512121246835.png)]

这是我们要处理的数据，代码如下

create database mybatis;
use mybatis;

drop table if exists tb_user;

create table tb_user(
	id int primary key auto_increment,
	username varchar(20),
	password varchar(20),
	gender char(1),
	addr varchar(30)
);

INSERT INTO tb_user VALUES (1, 'zhangsan', '123', '男', '北京');
INSERT INTO tb_user VALUES (2, '李四', '234', '女', '天津');
INSERT INTO tb_user VALUES (3, '王五', '11', '男', '西安');

2.5 对象的建立

我们要把数据里面的数据进行操作，而里面的数据我们可以看作是一个个实体，为一个实体类的对象，因此我们创建一个pojo包来创建User
把 tb_user 中的属性提取出来并建立实体类

优雅编程 lombok 插件 +依赖配置 scope 设置为provid

   <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>provided</scope>
      	</dependency>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wRCgo07z-1653730250785)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512122202814.png)]

在类上面添加以下代码即可完成全部的建立
- ```
@Data
@AllArgsConstructor
@NoArgsConstructor
```
效果图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3z6RzD3e-1653730250785)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512123215247.png)]

2.6接口的建立

我们需要建立一个UserDao接口来定义方法来处理处理，因为要处理的是User的数据，所以是Dao层，但mybait中习惯为Mapper
包括增删改查，这里我们只进行查询功能
定义一个查询方法，返回值为list

package mapper;

import pojo.User;

import java.util.List;

public interface UserMapper {

    //查询
    public List<User> findAll();

}

2.7创建接口映射的实现类

在resources中创建一个Mapper包，包下放UserMapper.xml 文件作为接口的映射实现类（必须保持一致）
查看文档代码如下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> 
<mapper namespace="org.mybatis.example.BlogMapper">
  <select id="selectBlog" resultType="Blog">
    select * from Blog where id = #{id}
  </select>
</mapper>

前四行不必修改
第五行调用Mapper管理，调用名称空间，空间名称为调用接口的全类名
后面则是对接口里面的方法进行重写 id 是重写的方法名，resuliType 则是方法返回值类型
重写好方法之后需要对核心配置文件中Mapper代理方法进行配置
- 即对2.3进行的补充

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fzi5vZMF-1653730250786)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512145950850.png)]

UserMapper代码如下

<?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="Mapper.UserMapper">

    <!--重写的方法 -->


</mapper>

mybatis-cofig代码如下

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


<configuration>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///db1?useSSl=false"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="Mapper/UserMapper.xml"/>
    </mappers>


</configuration>

2.8 重写接口方法

快速生成接口方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hp14wLGj-1653730250786)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512150145225.png)]

自动填写id 和resultType ,编写sql语句

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ie5dFfk3-1653730250787)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512150330951.png)]

2.9编写测试代码

在技术文档中找到从xml构建sqlSessionFactory

   ///加载核心配置文件
String resource = "org/mybatis/example/mybatis-config.xml";
    //mybatis提供的加载文件的功能
InputStream inputStream = Resources.getResourceAsStream(resource);
     //读取配置文件，创建工厂
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

构建好了sqlSessionFactory ，根据名字可知它是由一个工厂
之后在技术文档继续查询，可知我们可利用反射来建立一个接口的子类对象
之后我们只需要修改使用方法的内容即可

 try (SqlSession session = sqlSessionFactory.openSession()) {
            //利用反射， 创建一个指定接口的子类对象
            UserMapper mapper = session.getMapper(UserMapper.class);
            //使用方法
            List<User> Users = mapper.findAll();
            //输出
            System.out.println(Users);
        }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EG3JJpfM-1653730250788)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512151655290.png)]

输出结果如下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8ept5295-1653730250788)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512154127279.png)]

Mybatis增删改查

3.1环境准备

数据代码

-- 删除tb_brand表
drop table if exists tb_brand;
-- 创建tb_brand表
create table tb_brand (
    -- id 主键
    id int primary key auto_increment,
    -- 品牌名称
    brand_name varchar(20),
    -- 企业名称
    company_name varchar(20),
    -- 排序字段
    ordered int,
    -- 描述信息
    description varchar(100),
    -- 状态：0：禁用  1：启用
    status int
);
-- 添加数据
insert into tb_brand (brand_name, company_name, ordered, description, status)
values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
       ('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),
       ('小米', '小米科技有限公司', 50, 'are you ok', 1);
 SELECT*FROM tb_brand;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AtnSdOQi-1653730250789)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512155010827.png)]

需求
- 查：查询所有，多条件查询，单条件动态查询
- 添加信息并进行主键返回
- 修改全部字段与修改动态字段
- 删除一个和批量删除

3.2 查询所有

与上面类似，快速操作，结果发现结果有null值，分析原因

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WzJl2r4R-1653730250790)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512160749242.png)]
驼峰命名法与 sql 中的命名法冲突
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3nfrizqD-1653730250790)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512160604412.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K6gmfR1P-1653730250790)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512160614986.png)]
解决方法：驼峰自动转换
技术文档[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VcLYjgqy-1653730250791)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512161930980.png)]

    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

要主要放置位置
核心配置文件顺序如下
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b0UTFMWq-1653730250792)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512162027654.png)]

3.3查看详情：根据id返回brand

编写接口方法

public List<Brand> findById(int id);

重写方法

<!-- 根据id进行查询-->
    <select id="findById" resultType="pojo.Brand">
        select *
        from tb_brand
        where id = #{id};
    </select>

参数占位符
- #{} -> ？
- ￥{} -> 字符串的拼接
特殊字符的处理
- 转义字符
- CDATA区
  - ```
  <![CDATA[
  
  ]]>
```
代码测试

    //测试查询全部id
    @Test
    public void testSelectById() throws IOException {

        int id = 1 ;
        //加载核心配置文件
        String resource = "mybatis-config.xml";
        //mybatis提供的加载文件的功能
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //读取配置文件，创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        try (SqlSession session = sqlSessionFactory.openSession()) {
            //利用反射， 创建一个指定接口的子类对象
            BrandMapper mapper = session.getMapper(BrandMapper.class);
            //使用方法
            List<Brand> byId = mapper.findById(id);
            //输出
            System.out.println(byId);
        }
    }

3.4条件查询

mybatis中接收数据的三种方式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MeCE4QFu-1653730250792)(D:\自己的学习笔记\Maven&&Mybatis.assets\image-20220512164522344.png)]

@Param 散装参数 -> 有对个参数
一个实体类对象
一个map对象键的名称要和#{}中的名称对应一致
需要使用模糊查询
- "%"

3.4.1散装参数查询

放一块了直接

    //条件查询   返回brand集合 根据状态 ， 企业名字， 品牌名称 进行条件查询
 public List<Brand> findByCondition(@Param("status") int status, @Param("companyName")String companyName, @Param("brandName")String brandName);


//重写方法
    <select id="findByCondition" resultType="pojo.Brand">
        select *
        from tb_brand
        where status = #{status}
          and company_name like #{companyName}
          and brand_name like #{brandName};
    </select>

//测试
    //条件查询之散装参数
    @Test
    public void testSelectCondition() throws IOException {

        int status = 1 ;
        String companyName = "华为";
        String brand_name= "华为";

        //进行模糊处理
        companyName ="%"+ companyName+"%";
        brand_name ="%"+ brand_name+"%";

        //加载核心配置文件
        String resource = "mybatis-config.xml";
        //mybatis提供的加载文件的功能
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //读取配置文件，创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        try (SqlSession session = sqlSessionFactory.openSession()) {
            //利用反射， 创建一个指定接口的子类对象
            BrandMapper mapper = session.getMapper(BrandMapper.class);
            //使用方法
            List<Brand> byId = mapper.findByCondition(status,companyName,brand_name);
            //输出
            System.out.println(byId);
        }
    }

3.4.2 根据实体类对象查询

这就是把上面三个数据封装成了一个对象
我们无需改动sql语句索引我们可以在接口里面实现方法的重载

3.4.3 根据map进行查询

就是把brand 换成了map 直接上代码三个一块

接口

    //条件查询   返回brand集合 根据状态 ， 企业名字， 品牌名称 进行条件查询
    public List<Brand> findByCondition(@Param("status") int status, @Param("companyName")String companyName, @Param("brandName")String brandName);

    //条件查询 之  根据brand 进行查询 可以进行方法的重载
    public  List<Brand> findByCondition(Brand brand);
    //条件查询 之  Map 进行查询 可以进行方法的重载
    public  List<Brand> findByCondition(Map map);

sql


    <!-- 条件查询 之散装参数 之brand-->

    <select id="findByCondition" resultType="pojo.Brand">
        select *
        from tb_brand
        where status = #{status}
          and company_name like #{companyName}
          and brand_name like #{brandName};
    </select>

test

    //条件查询之散装参数 之brand
    @Test
    public void testSelectCondition() throws IOException {

        int status = 1 ;
        String companyName = "华为";
        String brandName= "华为";

        //进行模糊处理
        companyName ="%"+ companyName+"%";
        brandName ="%"+ brandName+"%";

        //new 一个brand ，添加参数
        Brand brand = new Brand();
        brand.setStatus(status);
        brand.setCompanyName(companyName);
        brand.setBrandName(brandName);

        //新建一个map集合
        Map map = new HashMap();
        map.put("status",status);
        map.put("companyName",companyName);
        map.put("brandName",brandName);


        //加载核心配置文件
        String resource = "mybatis-config.xml";
        //mybatis提供的加载文件的功能
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //读取配置文件，创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        try (SqlSession session = sqlSessionFactory.openSession()) {
            //利用反射， 创建一个指定接口的子类对象
            BrandMapper mapper = session.getMapper(BrandMapper.class);
            //使用方法1 散装
            List<Brand> byCondition1 = mapper.findByCondition(status,companyName,brandName);
            //使用方法2 brand
            List<Brand> byCondition2 = mapper.findByCondition(brand);
            //使用方法3 map
            List<Brand> byCondition3 = mapper.findByCondition(map);
            //输出
            System.out.println(byCondition1);
            System.out.println(byCondition2);
            System.out.println(byCondition3);
        }
    }

3.4.5条件查询的bug与动态 sql

当用户没有三个都输入的时候 sql语句会和预期不符合存在bug
因此我们要把sql 动态起来，sql语句要随着用户输入的值的变化而变化
使用if来进行判断，如果是int 则判断输入的是否为空如果是String判断是否是空和空字符串
- 其中的test中饭都数逻辑表达式
只需修改sql语句

    <!-- 动态条件查询 -->

    <select id="findByCondition2" resultType="pojo.Brand">
        select *
        from tb_brand
        where
        <if test="status != null">
            status = #{status}
        </if>
        <if test="companyName != null and companyName!='' ">
            and company_name like #{companyName}
        </if>
        <if test="brandName != null and brandName !='' ">
            and brand_name like #{brandName}
        </if>

    </select>

3.4.6动态 sql 的bug

当第一条语句被注释的时候，where 直接连接一个and了，sql语法就会出错
解决方案用来代替where


    <select id="findByCondition3" resultType="pojo.Brand">
        select *
        from tb_brand
       <where>
           <if test="status != null">
               status = #{status}
           </if>
           <if test="companyName != null and companyName!='' ">
               and company_name like #{companyName}
           </if>
           <if test="brandName != null and brandName !='' ">
               and brand_name like #{brandName}
           </if>
       </where>
    </select>

3.4.7单条件的动态查询

使用标签来进行选择与判断
要注意当用户一个都不选的时候，要把整张表格进行输出
- 使用标签写恒等式
- 或者使用标签更换where

<!-- 单条件动态查询-->
    <select id="findByConditionSingle" resultType="pojo.Brand">
        select *
        from tb_brand
        where
        <choose>
            <when test="status != null">
                status = #{status}
            </when>
            <when test="companyName != null and companyName!=''">
                and company_name like #{companyName}
            </when>
            <when test=" brandName != null and brandName !='' ">
                and brand_name like #{brandName}
            </when>
            <otherwise>
                1=1
            </otherwise>
        </choose>
    </select>


    <!-- 单条件动态查询2-->
    <select id="findByConditionSingle2" resultType="pojo.Brand">
        select *
        from tb_brand
        <where>
            <choose>
                <when test="status != null">
                    status = #{status}
                </when>
                <when test="companyName != null and companyName!=''">
                    and company_name like #{companyName}
                </when>
                <when test=" brandName != null and brandName !='' ">
                    and brand_name like #{brandName}
                </when>
            </choose>
        </where>
    </select>


 //条件查询  单条件动态查询
    @Test
    public void findByConditionSingle() throws IOException {

        // int status = 1;

        // String companyName = "华为";
        //String brandName = "华为";
        Brand brand = new Brand();
        //  brand.setStatus(status);

        //加载核心配置文件
        String resource = "mybatis-config.xml";
        //mybatis提供的加载文件的功能
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //读取配置文件，创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        try (SqlSession session = sqlSessionFactory.openSession()) {
            //利用反射， 创建一个指定接口的子类对象
            BrandMapper mapper = session.getMapper(BrandMapper.class);
            //使用方法1
            List<Brand> byConditionSingle = mapper.findByConditionSingle(brand);
            List<Brand> byConditionSingle2 = mapper.findByConditionSingle2(brand);
            //输出
            System.out.println(byConditionSingle);
            System.out.println(byConditionSingle2);
        }
    }

3.5 添加操作

接收一个没有id的数据进行数据的添加
要设置事务的提交
- 进行手动的事务提交 session.commit();
  - 在获取sqlSessionFactory的对象sqlSession设置为true 则表示事务的自动提交SqlSession session = sqlSessionFactory.openSession(true)

设置主键返回

```
 useGeneratedKeys="true" 
```

keyProperty="id"  //keyProperty 之间名称

    public void add(Brand brand);

    <!-- 基础添加-->
    <insert id="add">
        insert into tb_brand (brand_name, company_name, ordered, description, status)
        values (#{brandName},#{companyName},#{ordered},#{description},#{status});
    </insert>

 //基础添加
    @Test
    public void add() throws IOException {

        int status = 1;
        String companyName = "波导手机";
        String brandName = "波导";
        String description = "手机中的战斗机";
        int order = 100;
        
        Brand brand = new Brand();
        brand.setStatus(status);
        brand.setCompanyName(companyName);
        brand.setBrandName(brandName);
        brand.setDescription(description);
        brand.setOrdered(order);
        //加载核心配置文件
        String resource = "mybatis-config.xml";
        //mybatis提供的加载文件的功能
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //读取配置文件，创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        try (SqlSession session = sqlSessionFactory.openSession(true)) {
            //利用反射， 创建一个指定接口的子类对象
            BrandMapper mapper = session.getMapper(BrandMapper.class);
            //使用方法
            mapper.add(brand);
            //提交事务
            session.commit();
        }
    }

3.6 修改

更改sql语句

public int update(Brand brand);

    <update id="update">
        update tb_brand
        set
            brand_name = #{brandName},
            company_name = #{companyName},
            description = #{description},
            ordered = #{ordered},
            status = #{status}
        where id = #{id};
    </update>

    //基础更新
    @Test
    public void update() throws IOException {
        int id = 5;

        int status = 1;
        String companyName = "波导手机";
        String brandName = "波导";
        String description = "波导手机,手机中的战斗机";
        int order = 200;

        Brand brand = new Brand();
        brand.setStatus(status);
        brand.setCompanyName(companyName);
        brand.setBrandName(brandName);
        brand.setDescription(description);
        brand.setOrdered(order);
        brand.setId(id);
        //加载核心配置文件
        String resource = "mybatis-config.xml";
        //mybatis提供的加载文件的功能
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //读取配置文件，创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        try (SqlSession session = sqlSessionFactory.openSession()) {
            //利用反射， 创建一个指定接口的子类对象
            BrandMapper mapper = session.getMapper(BrandMapper.class);
            //使用方法
            int update = mapper.update(brand);
            System.out.println(update);
            //事务的提交
            session.commit();
        }
    }

动态修改
- if判断
  - 注意最后的逗号
- 标签 ->解决sql格式问题

    <update id="updatedynamic">
        update tb_brand
        <set>
            <if test="brandName != null and brandName != ''">
                brand_name = #{brandName},
            </if>
            <if test="companyName != null and companyName !=''">
                company_name = #{companyName},
            </if>
            <if test="ordered != null ">
                ordered = #{ordered},
            </if>
            <if test="description != null ">
                description = #{description},
            </if>
            <if test="status != null ">
                status = #{status}
            </if>
            where id = #{id};
        </set>
    </update>

3.7 删除

修改一个id

<delete id="delay">
    delete
    from tb_brand
    where id = #{id};
</delete>

修改多个id
- 批量删除
- 动态变化来进行遍历 separtor 分隔符，用逗号来分开
  - collection 表示要遍历的集合 item 表示遍历出来的元素
- @param来定义占位符

    //删除 根据id 进行删除
    public  void  delay(int id);

    //批量删除
    public void  delays(@Param("ints") int[] ints);

    //删除一个id
    @Test
    public void delay() throws IOException {
        int id = 3;
        //加载核心配置文件
        String resource = "mybatis-config.xml";
        //mybatis提供的加载文件的功能
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //读取配置文件，创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        try (SqlSession session = sqlSessionFactory.openSession()) {
            //利用反射， 创建一个指定接口的子类对象
            BrandMapper mapper = session.getMapper(BrandMapper.class);
            //使用方法
            mapper.delay(id);
            //事务的提交
            session.commit();
        }
    }

    //删除多个id
    @Test
    public void delays() throws IOException {
        int[] ids= {2,6};
        //加载核心配置文件
        String resource = "mybatis-config.xml";
        //mybatis提供的加载文件的功能
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //读取配置文件，创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        try (SqlSession session = sqlSessionFactory.openSession()) {
            //利用反射， 创建一个指定接口的子类对象
            BrandMapper mapper = session.getMapper(BrandMapper.class);
            //使用方法
            mapper.delays(ids);
            //事务的提交
            session.commit();
        }
    }

    <!-- 批量删除-->
    <delete id="delays">
        delete
        from tb_brand
        where id in (
            <foreach collection="ints" item="id"  separator=",">
        #{id}
    </foreach>
     )
    </delete>

象
BrandMapper mapper = session.getMapper(BrandMapper.class);
//使用方法
mapper.delay(id);
//事务的提交
session.commit();
}
}

//删除多个id
@Test
public void delays() throws IOException {
    int[] ids= {2,6};
    //加载核心配置文件
    String resource = "mybatis-config.xml";
    //mybatis提供的加载文件的功能
    InputStream inputStream = Resources.getResourceAsStream(resource);
    //读取配置文件，创建工厂
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    try (SqlSession session = sqlSessionFactory.openSession()) {
        //利用反射， 创建一个指定接口的子类对象
        BrandMapper mapper = session.getMapper(BrandMapper.class);
        //使用方法
        mapper.delays(ids);
        //事务的提交
        session.commit();
    }
}


```xml
    <!-- 批量删除-->
    <delete id="delays">
        delete
        from tb_brand
        where id in (
            <foreach collection="ints" item="id"  separator=",">
        #{id}
    </foreach>
     )
    </delete>