MyBatis高级------注解开发

最新推荐文章于 2024-05-30 14:52:09 发布
最新推荐文章于 2024-05-30 14:52:09 发布
阅读量179 收藏 1
点赞数 1
分类专栏： # MyBatis 文章标签： sql mysql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyuggjggg/article/details/119810770
版权

MyBatis高级

下面修改的路径，就是文件夹的位置
在这里插入图片描述

MyBatis注解开发

image-20210819193146478

简化操作步骤

常用注解

  • @Select( "查询的SQL语句”) :执行查询操作注解
  • @Insert(“新增的SQL语句”) : 执行新增操作注解
  • @Update(“修改的SQL语句”) :执行修改操作注解
  • @Delete(“删除的SQL语句”) :执行删除操作注解
查询操作
  • 创建接口和查询方法
  • 在核心配置文件中配置映射关系
  • 编写测试类

jdbc.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db0809pm
username=root
password=2184021338

log4j.properties

#Global logging configuration
# 输出信息显示，级别从高到低：ERROR WARN INFO DEBUG
# stdout:把信息输出到控制台上
log4j.rootLogger=DEBUG, stdout
#Console output...
# 下面的三个是输出格式
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

MyBatisConfig.xml

<?xml version="1.0" encoding="UTF-8"   ?><!--XML文档说明-->
<!--MyBatis的DTD约束：对标签的约束以及相应的提示的功能-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration：核心根标签-->
<configuration>

    <!--    引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>
<!--    配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>
<!--    起别名-->
    <typeAliases>
        <package name="com.yy.bEan"/>
    </typeAliases>

<!-- environments   配置数据库环境 ，环境可以有多高 default属性指定使用的是哪一个  -->
    <environments default="mysql"><!--default:指定是下面的哪一个数据库 -->
<!--     environment 配置数控环境 id属性代表唯一标识  -->
        <environment id="mysql">
<!--           transactionManager代表事务的管理 type属性，采用JDBC默认的事务处理 -->
            <transactionManager type="JDBC"></transactionManager>
<!--            dataSource 数据源的信息 type属性代表连接池-->
            <dataSource type="POOLED">
<!--             property 获取数据库连接的信息   -->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
<!--   mappers 代表引入映射配置文件 -->
<!--    配置映射关系-->
    <mappers>
        <package name="com.yy.mapper"/>
    </mappers>
</configuration>

接口

public interface PersonMapper {
    //查询全部
    @Select("SELECT * FROM person")
    public abstract List<Person> selectAll();
}

测试类

@Test
public void selectAll() throws Exception{
    //加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    //获取SqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    //通过个处对象获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //获取PersonMapper接口中的实现类对象
    PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);
    //调用实现类对象中的方法，接受结果
    List<Person> people = mapper.selectAll();
    //处理结果
    for(Person p : people){
        System.out.println(p);
    }
    //释放资源
    sqlSession.close();
    is.close();
}
/*
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1916575798.
DEBUG [main] - ==>  Preparing: SELECT * FROM person 
DEBUG [main] - ==> Parameters: 
DEBUG [main] - <==      Total: 3
Person{id=1, name='张三', age=23}
Person{id=2, name='李四', age=24}
Person{id=3, name='王五', age=25}
*/

image-20210819104317061

新增操作
  • 创建新增方法
  • 编写测试类

接口

public interface PersonMapper {
    //查询全部
    @Select("SELECT * FROM person")
    public abstract List<Person> selectAll();
    //新增操作
    @Insert("INSERT INTO person VALUES (#{id},#{name},#{age})")
    public abstract Integer insert(Person per);
}

测试类

@Test
public void insert() throws Exception{
    //加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    //获取SqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    //通过个处对象获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //获取PersonMapper接口中的实现类对象
    PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);

    //调用实现类对象中的方法，接受结果
   Person per = new Person(4,"赵六",20);
    Integer insert = mapper.insert(per);
    //处理结果
    System.out.println(insert);

    //释放资源
    sqlSession.close();
    is.close();
}
/*
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 205721196.
DEBUG [main] - ==>  Preparing: INSERT INTO person VALUES (?,?,?) 
DEBUG [main] - ==> Parameters: 4(Integer), 赵六(String), 20(Integer)
DEBUG [main] - <==    Updates: 1
1
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@c430e6c]
DEBUG [main] - Returned connection 205721196 to pool.

Process finished with exit code 0

*/

image-20210819104950372

修改操作
  • 创建修改方法（在接口当中创建）
  • 编写测试类
//修改操作
@Update("UPDATE person SET name=#{name},age=#{age} WHERE id=#{id}")
public  abstract Integer update(Person per);

@Test
public void update() throws Exception{
    //加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    //获取SqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    //通过个处对象获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //获取PersonMapper接口中的实现类对象
    PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);

    //调用实现类对象中的方法，接受结果
    Person per = new Person(4,"赵六",30);
    Integer update = mapper.update(per);
    //处理结果
    System.out.println(update);

    //释放资源
    sqlSession.close();
    is.close();
}
/*
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 438589491.
DEBUG [main] - ==>  Preparing: UPDATE person SET name=?,age=? WHERE id=? 
DEBUG [main] - ==> Parameters: 赵六(String), 30(Integer), 4(Integer)
DEBUG [main] - <==    Updates: 1
1
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1a245833]

*/

image-20210819105637692

删除操作
  • 创建删除方法（在接口当中创建）
  • 编写测试类
//删除操作
@Delete("DELETE FROM person WHERE id=#{id}")
public abstract Integer delete(Integer id);

@Test
public void delete() throws Exception{
    //加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    //获取SqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    //通过个处对象获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //获取PersonMapper接口中的实现类对象
    PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);

    //调用实现类对象中的方法，接受结果
    Integer delete = mapper.delete(4);
    //处理结果
    System.out.println(delete);

    //释放资源
    sqlSession.close();
    is.close();
}
/*
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1250121181.
DEBUG [main] - ==>  Preparing: DELETE FROM person WHERE id=? 
DEBUG [main] - ==> Parameters: 4(Integer)
DEBUG [main] - <==    Updates: 1
1
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a8355dd]
DEBUG [main] - Returned connection 1250121181 to pool.

Process finished with exit code 0

*/

image-20210819105942091

小结

image-20210819110143616

MyBatis注解实现多表操作

数据使用是进阶内容里面的多表操作数据

一对一
环境准备
	@Results :封装映射关系的父注解。
	Result[ value() :定义了Result数组
		@Result :封装映射关系的子注解。
			column属性:查询出的表中字段名称
			property属性:实体对象中的属性名称
			javaType属性:被包含对象的数据类型
			one属性:一对一查询固定属性
			@One :一对一查询的注解。
				select属性:指定调用某个接口中的方法

MYBatisConfig.xml

就修改路径就可以

<?xml version="1.0" encoding="UTF-8"   ?><!--XML文档说明-->
<!--MyBatis的DTD约束：对标签的约束以及相应的提示的功能-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration：核心根标签-->
<configuration>

    <!--    引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>
<!--    配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>
<!--    起别名-->
    <typeAliases>
        <package name="com.yy.bEan"/>
    </typeAliases>

<!-- environments   配置数据库环境 ，环境可以有多高 default属性指定使用的是哪一个  -->
    <environments default="mysql"><!--default:指定是下面的哪一个数据库 -->
<!--     environment 配置数控环境 id属性代表唯一标识  -->
        <environment id="mysql">
<!--           transactionManager代表事务的管理 type属性，采用JDBC默认的事务处理 -->
            <transactionManager type="JDBC"></transactionManager>
<!--            dataSource 数据源的信息 type属性代表连接池-->
            <dataSource type="POOLED">
<!--             property 获取数据库连接的信息   -->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
<!--   mappers 代表引入映射配置文件 -->
<!--    配置映射关系-->
    <mappers>
        <package name="com.yy.one_to_one"/>
    </mappers>
</configuration>

PersonMapper.java

public interface PersonMapper {
    //根据id查询
    @Select("SELECT * FROM person WHERE id=#{id}")
    public abstract Person selectById(Integer id);
}

CardMapper.java

public interface CardMappper {
    //查询全部
    @Select("SELECT * FROM card")
    //Results：通过他里面的属性来完成对象以及表中数据的赋值关系
    @Results({
            //Result：数组，封装数据
            @Result(column = "id",property = "id"),
            @Result(column = "number",property = "number"),
            //为person类赋值
            @Result(
                    property = "p",//被包含对象的名字
                    javaType = Person.class,//被包含对象的实际数据类型
                    //column:根据card表中查询的哪一个字段来去查询Person表
                    column = "pid",//根据查询出的card表中的pid字段来查询person表
                    /*
                    one、@One 一对一查询的固定写法
                    select属性：指定调用哪个接口中的哪个方法
                     */
                    one = @One(select = "com.yy.one_to_one.PersonMapper.selectById")
            )

    })
    public abstract List<Card> selectAll();
}

测试类

@Test
    public void selectAll() throws Exception{
        //加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        //获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //通过个处对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //获取PersonMapper接口中的实现类对象
        CardMappper mapper = sqlSession.getMapper(CardMappper.class);
        //调用实现类对象中的方法，接受结果
        List<Card> cards = mapper.selectAll();
        //处理结果
        for(Card c : cards){
            System.out.println(c);
        }
        //释放资源
        sqlSession.close();
        is.close();
    }
/*结果
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1072377306.
DEBUG [main] - ==>  Preparing: SELECT * FROM card 
DEBUG [main] - ==> Parameters: 
DEBUG [main] - ====>  Preparing: SELECT * FROM person WHERE id=? 
DEBUG [main] - ====> Parameters: 1(Integer)
DEBUG [main] - <====      Total: 1
DEBUG [main] - ====>  Preparing: SELECT * FROM person WHERE id=? 
DEBUG [main] - ====> Parameters: 2(Integer)
DEBUG [main] - <====      Total: 1
DEBUG [main] - ====>  Preparing: SELECT * FROM person WHERE id=? 
DEBUG [main] - ====> Parameters: 3(Integer)
DEBUG [main] - <====      Total: 1
DEBUG [main] - <==      Total: 3
Card{id=1, number='12345', p=Person{id=1, name='张三', age=23}}
Card{id=2, number='12346', p=Person{id=2, name='李四', age=24}}
Card{id=3, number='12347', p=Person{id=3, name='王五', age=25}}
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@3feb2dda]

*/
一对多
环境准备
	@Results :封装映射关系的父注解。
		Result[ value() : 定义了Result数组
			@Result :封装映射关系的子注解。
				column属性:查询出的表中字段名称
				property属性:实体对象中的属性名称
				javaType属性:被包含对象的数据类型
				many属性:一对多查询固定属性
					@Many :一对多查询的注解。
						select属性:指定调用某个接口中的方法

MyBatisConfig.xml
这样写的话，可以把yy下面的所有java文件都给配置上，相对于作用域扩大

<!--    配置映射关系-->
    <mappers>
        <package name="com.yy"/>
    </mappers>

StudentMapper.java

public interface StudentMapper {
    //根据id查询
    @Select("SELECT * FROM student1 WHERE id=#{id}")
    public abstract List<Student> selectByCid(Integer cid);

}

ClassesMapper.java

public interface ClassesMapper {
    //查询全部
    @Select("SELECT * FROM classes")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(
                    property = "students",//被包含对象的变量名字
                    javaType = List.class,//被包含对象的实际的数据类型
                    column = "id",          //根据查询出的classes表的id字段去查询student1表
                    /*
                    many、@Many  一对多查询的固定写法
                    select属性：指定调用哪个接口中的哪个查询方法
                     */
                    many = @Many(select = "com.yy.one_to_many.StudentMapper.selectByCid")
            )
    })
    public abstract List<Classes> selectAll();
}

测试类

@Test
public void selectAll() throws Exception{
    //加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    //获取SqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    //通过个处对象获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //获取PersonMapper接口中的实现类对象
    ClassesMapper mapper = sqlSession.getMapper(ClassesMapper.class);
    //调用实现类对象中的方法，接受结果
    List<Classes> classes = mapper.selectAll();
    //处理结果
    for (Classes cls : classes){
        System.out.println(cls.getId()+","+cls.getName());
        List<Student> students = cls.getStudents();
        for(Student student : students){
            System.out.println("\t"+student);
        }
    }
    //释放资源
    sqlSession.close();
    is.close();
}
/*
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 477376212.
DEBUG [main] - ==>  Preparing: SELECT * FROM classes 
DEBUG [main] - ==> Parameters: 
DEBUG [main] - ====>  Preparing: SELECT * FROM student1 WHERE id=? 
DEBUG [main] - ====> Parameters: 1(Integer)
DEBUG [main] - <====      Total: 1
DEBUG [main] - ====>  Preparing: SELECT * FROM student1 WHERE id=? 
DEBUG [main] - ====> Parameters: 2(Integer)
DEBUG [main] - <====      Total: 1
DEBUG [main] - <==      Total: 2
1,一班
	Student{id=1, name='张三', age=23}
2,二班
	Student{id=2, name='李四', age=24}
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1c742ed4]

*/
多对多

和一对多差不多，只是在第一条sql语句时需要修改，注意sql语句的编写

环境准备
@Results :封装映射关系的父注解。
Result[ value() :定义了Result数组
@Result :封装映射关系的子注解。
column属性:查询出的表中字段名称
property属性:实体对象中的属性名称
javaType属性:被包含对象的数据类型
many属性:一对多查询固定属性
@Many :一对多查询的注解。
select属性:指定调用某个接口中的方法

MyBatisConfig.xml

因为上面的mapper设置为包的路径，所以现在不用再去修改路径了

CourseMapper.java

public interface CourseMapper {
    //根据学生id查询所选课程
    @Select("SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid =c.id AND sc.id=#{id}")
    public abstract List<Course> selectBySid(Integer id);
}

StudentMapper.java

public interface StudentMapper {
    //查询全部
    @Select("SELECT * FROM student1")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(column = "age",property = "age"),
            @Result(
                    property = "courses",//被包含对象的变量名
                    javaType = List.class,//被包含对象的实际数据类型
                    column = "id",      //根据查询出student1表的id来作为关联条件，去查询中间表和课程表
                    /*
                    many、@Many 一对多查询的固定写法
                    select属性：指定调用哪个接口中的哪个查询方法
                     */
                    many = @Many(select = "com.yy.many_to_many.CourseMapper.selectBySid")

            )
    })
    public abstract List<Student1> selectAll();
}

测试类

@Test
public void selectAll() throws Exception{
    //加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    //获取SqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    //通过个处对象获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //获取PersonMapper接口中的实现类对象
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    //调用实现类对象中的方法，接受结果
    List<Student1> student1s = mapper.selectAll();
    //处理结果
    for (Student1 student1 : student1s){
        System.out.println(student1.getId()+","+student1.getName()+","+student1.getAge());
        List<Course> courses = student1.getCourses();
        for(Course course : courses){
            System.out.println("\t"+course);
        }
    }
    //释放资源
    sqlSession.close();
    is.close();
}
/*
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1649320501.
DEBUG [main] - ==>  Preparing: SELECT * FROM student1 
DEBUG [main] - ==> Parameters: 
DEBUG [main] - ====>  Preparing: SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid =c.id AND sc.id=? 
DEBUG [main] - ====> Parameters: 1(Integer)
DEBUG [main] - <====      Total: 1
DEBUG [main] - ====>  Preparing: SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid =c.id AND sc.id=? 
DEBUG [main] - ====> Parameters: 2(Integer)
DEBUG [main] - <====      Total: 1
DEBUG [main] - ====>  Preparing: SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid =c.id AND sc.id=? 
DEBUG [main] - ====> Parameters: 3(Integer)
DEBUG [main] - <====      Total: 1
DEBUG [main] - ====>  Preparing: SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid =c.id AND sc.id=? 
DEBUG [main] - ====> Parameters: 4(Integer)
DEBUG [main] - <====      Total: 1
DEBUG [main] - <==      Total: 4
1,张三,23
	Course{id=1, name='语文'}
2,李四,24
	Course{id=2, name='数学'}
3,王五,25
	Course{id=1, name='语文'}
4,赵六,26
	Course{id=2, name='数学'}
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@624ea235]

*/

优化

public interface StudentMapper {
    //查询全部
    @Select("SELECT DISTINCT s.id,s.name,s.age FROM student1 s,stu_cr sc WHERE sc.sid=s.id")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(column = "age",property = "age"),
            @Result(
                    property = "courses",//被包含对象的变量名
                    javaType = List.class,//被包含对象的实际数据类型
                    column = "id",      //根据查询出student1表的id来作为关联条件，去查询中间表和课程表
                    /*
                    many、@Many 一对多查询的固定写法
                    select属性：指定调用哪个接口中的哪个查询方法
                     */
                    many = @Many(select = "com.yy.many_to_many.CourseMapper.selectBySid")

            )
    })
    public abstract List<Student1> selectAll();
}

结果

/*
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1293203138.
DEBUG [main] - ==>  Preparing: SELECT DISTINCT s.id,s.name,s.age FROM student1 s,stu_cr sc WHERE sc.sid=s.id 
DEBUG [main] - ==> Parameters: 
DEBUG [main] - ====>  Preparing: SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid =c.id AND sc.id=? 
DEBUG [main] - ====> Parameters: 1(Integer)
DEBUG [main] - <====      Total: 1
DEBUG [main] - ====>  Preparing: SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid =c.id AND sc.id=? 
DEBUG [main] - ====> Parameters: 2(Integer)
DEBUG [main] - <====      Total: 1
DEBUG [main] - <==      Total: 2
1,张三,23
	Course{id=1, name='语文'}
2,李四,24
	Course{id=2, name='数学'}
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@4d14b6c2]
小结
@Results :封装映射关系的父注解。
	Result[ value0 :定义了Result数组
@Result :封装映射关系的子注解。
	column属性:查询出的表中字段名称
	property属性:实体对象中的属性名称;
	javaType属性:被包含对象的数据类型
	one属性:-对一 查询固定属性
	many属性:一对多查询固定属性
@One :- 对一查询的注解。
	select属性:指定调用某个接[中的方法
@Many :一对多查询的注解。
	select属性:指定调用某个接口中的方法

MyBatis构建SQL语句

介绍

好处：降低出错率

image-20210819193931794

package com.yy.sql;

import org.apache.ibatis.jdbc.SQL;

/**
 * @author Marston
 * @date 2021/8/19
 */
public class SqlTest {
    public static void main(String[] args) {
        String sql = getSql();
        System.out.println(sql);//SELECT * FROM student"
    }
    //定义方法，获取查询student表的sql语句
//    private static String getSql() {
//        String sql = "SELECT * FROM student";
//        return sql;
//    }
    private static String getSql() {
        String sql = new SQL(){
            {
                SELECT("*");
                FROM("student");
            }
        }.toString();
        return sql;
    }
}
/*
两个方法的返回值都一样
*/

image-20210819194750369

查询操作
定义功能类并提供获取查询的SQL语句的方法。

@SelectProvider :生成查询用的SQL语句注解。
	type属性:生成SQL语句功能类对象
	method属性:指定调用方法

ReturnSql.java

public class ReturnSql {
    //定义方法，返回查询的sql语句
    public String getSelectAll(){
        return new SQL(){
            {
                SELECT("*");
                FROM("person");
            }
        }.toString();
    }
}

PersonMapper.java

package com.yy.mapper;

import com.yy.bEan.Person;
import com.yy.sql.ReturnSql;
import org.apache.ibatis.annotations.*;

import java.util.List;

/**
 * @author Marston
 * @date 2021/8/19
 */
public interface PersonMapper {
    /*
    //查询全部
    @Select("SELECT * FROM person")
    public abstract List<Person> selectAll();
    //新增操作
    @Insert("INSERT INTO person VALUES (#{id},#{name},#{age})")
    public abstract Integer insert(Person per);
    //修改操作
    @Update("UPDATE person SET name=#{name},age=#{age} WHERE id=#{id}")
    public  abstract Integer update(Person per);
    //删除操作
    @Delete("DELETE FROM person WHERE id=#{id}")
    public abstract Integer delete(Integer id);

     */
    //查询全部
    //@Select("SELECT * FROM person")
    @SelectProvider(type = ReturnSql.class,method = "getSelectAll")
    public abstract List<Person> selectAll();
    //新增操作
    @Insert("INSERT INTO person VALUES (#{id},#{name},#{age})")
    public abstract Integer insert(Person per);
    //修改操作
    @Update("UPDATE person SET name=#{name},age=#{age} WHERE id=#{id}")
    public  abstract Integer update(Person per);
    //删除操作
    @Delete("DELETE FROM person WHERE id=#{id}")
    public abstract Integer delete(Integer id);
}


@Test
public void selectAll() throws Exception{
    //加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    //获取SqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    //通过个处对象获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //获取PersonMapper接口中的实现类对象
    PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);
    //调用实现类对象中的方法，接受结果
    List<Person> people = mapper.selectAll();
    //处理结果
    for(Person p : people){
        System.out.println(p);
    }
    //释放资源
    sqlSession.close();
    is.close();
}
/*
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 93199773.
DEBUG [main] - ==>  Preparing: SELECT * FROM person 
DEBUG [main] - ==> Parameters: 
DEBUG [main] - <==      Total: 3
Person{id=1, name='张三', age=23}
Person{id=2, name='李四', age=24}
Person{id=3, name='王五', age=25}
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@58e1d9d]
*/
新增操作
定义功能类并提供获取新增的SQL语句的方法。

@InsertProvider :生成新增用的SQL语句注解。
	type属性:生成SQL语句功能类对象
	method属性:指定调用方法

ReturnSql.java

public class ReturnSql {
    //定义方法，返回查询的sql语句
    public String getSelectAll(){
        return new SQL(){
            {
                SELECT("*");
                FROM("person");
            }
        }.toString();
    }

    //定义方法，返回新增的sql语句
    public String getInsert(Person per){
        return new SQL(){
            {
                INSERT_INTO("person");
                INTO_VALUES("#{id},#{name},#{age}");
            }
        }.toString();
    }
}

PersonMapper.java

package com.yy.mapper;

import com.yy.bEan.Person;
import com.yy.sql.ReturnSql;
import org.apache.ibatis.annotations.*;

import java.util.List;

/**
 * @author Marston
 * @date 2021/8/19
 */
public interface PersonMapper {
    /*
    //查询全部
    @Select("SELECT * FROM person")
    public abstract List<Person> selectAll();
    //新增操作
    @Insert("INSERT INTO person VALUES (#{id},#{name},#{age})")
    public abstract Integer insert(Person per);
    //修改操作
    @Update("UPDATE person SET name=#{name},age=#{age} WHERE id=#{id}")
    public  abstract Integer update(Person per);
    //删除操作
    @Delete("DELETE FROM person WHERE id=#{id}")
    public abstract Integer delete(Integer id);

     */
    //查询全部
    //@Select("SELECT * FROM person")
    @SelectProvider(type = ReturnSql.class,method = "getSelectAll")
    public abstract List<Person> selectAll();
    //新增操作
//    @Insert("INSERT INTO person VALUES (#{id},#{name},#{age})")
    @InsertProvider(type = ReturnSql.class,method = "getInsert")
    public abstract Integer insert(Person per);
    //修改操作
    @Update("UPDATE person SET name=#{name},age=#{age} WHERE id=#{id}")
    public  abstract Integer update(Person per);
    //删除操作
    @Delete("DELETE FROM person WHERE id=#{id}")
    public abstract Integer delete(Integer id);
}

测试类

@Test
public void insert() throws Exception{
    //加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    //获取SqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    //通过个处对象获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //获取PersonMapper接口中的实现类对象
    PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);

    //调用实现类对象中的方法，接受结果
   Person per = new Person(4,"赵六",20);
    Integer insert = mapper.insert(per);
    //处理结果
    System.out.println(insert);

    //释放资源
    sqlSession.close();
    is.close();
}
/*
EBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 136393487.
DEBUG [main] - ==>  Preparing: INSERT INTO person VALUES (?,?,?) 
DEBUG [main] - ==> Parameters: 4(Integer), 赵六(String), 20(Integer)
DEBUG [main] - <==    Updates: 1
1
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@821330f]

*/

image-20210819195956722

修改操作
定义功能类并提供获取修改的SQL语句的方法。

@UpdateProvider :生成修改用的SQL语句注解。
	type属性:生成SQL语句功能类对象
	method属性:指定调用方法

ReturnSql.java

//定义方法，返回修改的sql语句
public String getUpdate(Person per){
    return new SQL(){
        {
            UPDATE("person");
            SET("name=#{name}","age=#{age}");
            WHERE("id=#{id}");
        }
    }.toString();
}

//修改操作
//@Update("UPDATE person SET name=#{name},age=#{age} WHERE id=#{id}")
@UpdateProvider(type = ReturnSql.class,method = "getUpdate")
public  abstract Integer update(Person per);

@Test
public void update() throws Exception{
    //加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    //获取SqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    //通过个处对象获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //获取PersonMapper接口中的实现类对象
    PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);

    //调用实现类对象中的方法，接受结果
    Person per = new Person(4,"赵六",30);
    Integer update = mapper.update(per);
    //处理结果
    System.out.println(update);

    //释放资源
    sqlSession.close();
    is.close();
}
/*
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 959629210.
DEBUG [main] - ==>  Preparing: UPDATE person SET name=?, age=? WHERE (id=?) 
DEBUG [main] - ==> Parameters: 赵六(String), 30(Integer), 4(Integer)
DEBUG [main] - <==    Updates: 1
1
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@3932c79a]
DEBUG [main] - Returned connection 959629210 to pool.

Process finished with exit code 0

*/

image-20210819200447287

删除操作
定义功能类并提供获取删除的SQL语句的方法。

@DeleteProvider :生成删除用的SQL语句注解。
	type属性:生成SQL语句功能类对象
	method属性:指定调用方法

//定义方法，返回删除的sql语句
public String getDelete(Integer id){
    return new SQL(){
        {
            DELETE_FROM("person");
            WHERE("id=#{id}");
        }
    }.toString();
}

//删除操作
//@Delete("DELETE FROM person WHERE id=#{id}")
@DeleteProvider(type = ReturnSql.class,method = "getDelete")
public abstract Integer delete(Integer id);

@Test
public void delete() throws Exception{
    //加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    //获取SqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    //通过个处对象获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //获取PersonMapper接口中的实现类对象
    PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);

    //调用实现类对象中的方法，接受结果
    Integer delete = mapper.delete(4);
    //处理结果
    System.out.println(delete);

    //释放资源
    sqlSession.close();
    is.close();
}
/*
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 603305436.
DEBUG [main] - ==>  Preparing: DELETE FROM person WHERE (id=?) 
DEBUG [main] - ==> Parameters: 4(Integer)
DEBUG [main] - <==    Updates: 1
1
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@23f5b5dc]
DEBUG [main] - Returned connection 603305436 to pool.

Process finished with exit code 0

*/

image-20210819200911935

小结
org.apache.ibatis.jdbc.SQL :构建SQL语句的功能类。通过一些方法来代替 SQL语句的关键字。
	SELECTO
	FROMO
	WHEREO
	INSERT INTOO
	VALUESO
	UPDATE(
	DELETE_ FROM0

@SelectProvider :成查询用的SQL语句注解。
@InsertProvider :生成新增用的SQL语句注解。
@UpdateProvider :生成修改用的SQL语句注解。
@DeleteProvider :生成删除用的SQL语句注解。
	type属性:生成SQL语句功能类对象
	method属性:指定调用方法
?abc!
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
经典三层框架初识--一.Mybatis(下)使用注解和高级映射
XiaodunLP的博客
10-25 357
一.使用注解实现 说到现在,我们发现,mybatis代码已经简化了很多了.和以前相比,我们不用去编写它的实现类.而是由mapper代理自动帮我们生成.但是我们还有一种更为经典的方式.mapper代理我们前面说的是通过xml配置文件的方式来实现的,那下面我们介绍一下使用注解来实现.annotations--注释. 我们通过注解实现的话,映射配置文件--我们前面的UserMapper就不需要了.删...
Mybatis高级注解使用
a907691592的博客
07-24 466
Mybatis 除了使用@Select @Update等普通注解来写sql之外，还有高级sql。像下面这种： public class UserMapperProvider { public String getUserById1(Long id){ StringBuffer sql = new StringBuffer("select"); sql....
MyBatis篇】四. MyBatis高级第三章 注解开发（共三章）
TheNew_One的博客
01-07 119
MyBatis高级第三章 注解开发 github源码(day56-mybatis-senior) https://github.com/1196557363/ideaMavenProject 【MyBatis篇】四. MyBatis高级第一章 #{}和${}符号的区别 【MyBatis篇】四. MyBatis高级第二章 缓存 项目准备 因为在同一个module中所以大环境不用改,参考第一章的项目...
SSM-MyBatis深层了解（使用注解开发和SQL构建对象）
YINJOER的博客
06-21 291
MyBatis进阶 今天给大家分享以下几个内容 注解实现单表开发 注解实现多表操作 MyBatis的SQL构建语句 先给大家介绍以下MyBatis注解开发的几个关键字 注解实现单表开发 在一个表中操作数据比较简单，这里我就直接把增删改查放到一起，步骤如下： 先导入MyBatis相关的jar包（因为要用到JDBC相关的类和日志文件所以导入了相应的包） 配置MyBatis核心配置文件 <settings> <!--在控制台显示SQL语句-->
黑马程序员视频教程学习mybatis框架常用注释SQL语句学习笔记？
qq_45137584的博客
01-23 444
mybatis学习笔记**mybatis注解之一对一查询：****mybatis注解之一对多查询：****mybatis开启二级缓存** 黑马程序员ssm框架视频教程之mybatis注解学习笔记。 软件： IDEA+Navicat(mysql) 数据表： 常用注释增删改查SQL语句 功能 注释SQL常用增删改查语句 查 @Select("select *from user ") 增 @Insert("insert into user(username,address,sex,birth
Mybatis 开发注解快速入门
09-01
mybatis是一个支持普通SQL查询，存储过程和高级映射的优秀持久层框架。这篇文章主要介绍了Mybatis 开发注解快速入门的相关资料,需要的朋友可以参考下
ssmBlog：使用springboot + vue.js + axios完成并执行
02-05
SQL mapper优化使用Mybatis更高级的注解API删除一些无用的 服务层异常处理与统一返回解内部 controller层异常处理 各个方法测试用例补全 2019 1月版本更新 登陆后台地址更改/admin/login.html vue-admintle jar包...
SpringBoot笔记-下篇.pdf
05-05
107）注解简化我们开发； • Cache接口为缓存的组件规范定义，包含缓存的各种操作集合； • Cache接 口下Spring提供了各种xxxCache的实现；如RedisCache，EhCacheCache , ConcurrentMapCache 等； • 每次调用需要...
百度地图开发java源码-project:springmvc+mybatis
06-06
MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。 ###shiro Shiro 是一个 Apache Incubator 项目，旨在简化身份验证和授权...
程序员面试刷题的书哪个好-LearnMybatis:学习Mybatis
07-07
SQL、存储过程以及高级映射的优秀的持久层框架。 MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。 MyBatis 可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（ Plain Old Java ...
Mybatis-注解开发（多表）
金鳞踏雨
03-01 470
实现复杂关系映射之前我们可以在映射文件中通过配置<resultMap>来实现，使用注解开发后，我们可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置。
Mybatis注解开发---实现增删改查
行行失故路
04-01 2332
1. 新建maven项目 导入依赖 在porn.xml中写入依赖 <!--mybatis坐标--> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.4.5</version> </dependency> <!--mysql驱动坐标--&g
Mybatis常用注解总结
qq_39116776的博客
12-13 2290
简介 什么是 MyBatis ？ MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。 m...
实验7 Mybatis注解式开发
weixin_51821844的博客
11-14 630
1、了解Mybatis基础知识； 2、理解Mybatis工作原理 3、掌握Mybatis的注解式开发。
JavaEE实验五： Mybatis注解
小猪宝宝的博客
07-12 635
实验五： Mybatis注解 实验内容： 创建学生表和班级表，学生表：student(id,name,age,class_id),班级表：class(id,classname)， 并输入几行数据。 使用MyBatis注解实现下列要求； （1）MyBatis注解实现查询操作。查询id为2的学生的信息。 （2）MyBatis注解实现修改操作。修改id为4的学生的姓名修改为李雷，年龄修改为21。 （3）MyBatis注解实现一对多查询。查询出二班所有学生的信息。...
基础—SQL—DQL（数据查询语言）聚合函数
最新发布
m0_74363339的博客
05-30 358
这篇博客主要讲到了SQL分类中的DQL（数据查询语言）—聚合函数的讲解，聚合函数比较简单，但它主要配合着分组查询进行数据查询的操作，注意NULL的字段值不参与聚合函数的运算......
PostgreSQL常用插件
PGCCC的博客
05-29 519
1.提供 PostgreSQL 实例的操作系统级别的资源使用情况，包括缓存命中率和磁盘 IO 等。通过使用这些插件，您可以大大增强 PostgreSQL 的功能，满足各种复杂的应用需求。1.提供三元组（trigram）相似度匹配和索引功能，常用于模糊搜索和文本相似度匹配。1.增加对地理空间数据的支持，使 PostgreSQL 成为一个功能强大的空间数据库。1.PostgreSQL 的过程语言，允许用户编写存储过程和触发器。1.基于逻辑复制的插件，提供更细粒度的数据复制控制和双向复制能力。
SQL Server定期收缩日志文件详细步骤——基于SQL Server 2012
lxcw_sir的博客
05-29 349
SQL Server定期收缩日志文件详细步骤——基于SQL Server 2012
postgressql——Tuple学习（2）
Re_view的博客
05-27 273
postgressql——Tuple学习（2）
mybatis-plus的高级用法
09-13
MyBatis-Plus 是一个基于 MyBatis 的增强工具，提供了许多便捷的功能和高级用法，以提升开发效率。以下是一些 MyBatis-Plus 的高级用法： 1. 代码生成器：MyBatis-Plus 提供了一个代码生成器，能够根据数据库表结构自动生成对应的实体类、Mapper 接口以及 XML 映射文件，极大地减少了手动编写重复代码的工作量。 2. 自动填充：通过使用 @TableField 注解中的 fill 属性，可以实现在插入或更新数据时自动填充某些字段的值，例如创建时间、更新时间等。 3. 条件构造器：MyBatis-Plus 提供了强大的条件构造器，可通过链式调用的方式灵活地构建查询条件。例如，使用 wrapper.eq("name", "张三") 可以构造出 name = '张三' 的查询条件。 4. 分页查询：通过使用 Page 类，可以实现简单的分页查询。可以通过 PageHelper.startPage 方法设置页码和每页显示数量，并将 Page 对象传入查询方法中，查询结果将自动填充到 Page 对象中。 5. 逻辑删除：通过在实体类的字段上标注 @TableLogic 注解，可以实现逻辑删除的功能。被标记为逻辑删除的字段在删除操作时不会直接删除记录，而是更新该字段的值表示删除状态。 6. 动态 SQL：MyBatis-Plus 提供了强大的动态 SQL 语法支持，可以根据不同条件动态生成不同的 SQL 语句，提供了 if、choose、when、otherwise 等标签，使得 SQL 编写更加灵活。 以上是 MyBatis-Plus 的一些高级用法，它们都能够帮助开发人员简化开发流程并提高效率。更多详细的用法可以参考 MyBatis-Plus 官方文档。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

?abc!

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值