Java Web学习day19------Mybatis（注解、注解实现多表开发、构建SQL）

最新推荐文章于 2024-11-09 12:43:52 发布
最新推荐文章于 2024-11-09 12:43:52 发布
阅读量222 收藏 1
点赞数
分类专栏： Java Web学习 文章标签： mybatis java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dsh789/article/details/111193820
版权
本文详细介绍了如何在MyBatis中使用注解开发CRUD操作，涵盖一对一、一对多、多对多的关系映射，并展示了如何构建SQL语句和动态SQL。此外，还提供了项目改进案例，包括环境搭建、配置调整和接口代理的实现。
摘要由CSDN通过智能技术生成

注解

一. 注解开发实现CRUD【重要】

1. Mapper接口中使用注解

public interface StudentMapper {
    //查询全部
    @Select("SELECT * FROM student")
    public abstract List<Student> selectAll();

    //新增操作
    @Insert("INSERT INTO student VALUES (#{id},#{name},#{age})")
    public abstract Integer insert(Student stu);

    //修改操作
    @Update("UPDATE student SET name=#{name},age=#{age} WHERE id=#{id}")
    public abstract Integer update(Student stu);

    //删除操作
    @Delete("DELETE FROM student WHERE id=#{id}")
    public abstract Integer delete(Integer id);
}

2. 核心配置文件引入Mapper

  文件结构
在这里插入图片描述

<!--核心配置文件中配置-->
<!--加载映射文件-->
<mappers>
  <!--引入mapper接口的位置-->
  <!--使用mapper配置文件配置，class里面使用Mapper类的全类名-->
  <!--<mapper class="com.itheima.mapper.StudentMapper"/>-->
  <!--引入整个mapper包（扫包）-->
  <package name="com.itheima.mapper"/>
</mappers>

3. 测试类

public class Test01 {
    @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        //5.调用实现类对象中的方法，接收结果
        List<Student> list = mapper.selectAll();
        //6.处理结果
        for (Student student : list) {
            System.out.println(student);
        }
        //7.释放资源
        sqlSession.close();
        is.close();
    }

    @Test
    public void insert() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        //5.调用实现类对象中的方法，接收结果
        Student stu = new Student(4,"赵六",26);
        Integer result = mapper.insert(stu);
        //6.处理结果
        System.out.println(result);
        //7.释放资源
        sqlSession.close();
        is.close();
    }

    @Test
    public void update() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        //5.调用实现类对象中的方法，接收结果
        Student stu = new Student(4,"赵六",36);
        Integer result = mapper.update(stu);
        //6.处理结果
        System.out.println(result);
        //7.释放资源
        sqlSession.close();
        is.close();
    }

    @Test
    public void delete() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        //5.调用实现类对象中的方法，接收结果
        Integer result = mapper.delete(4);
        //6.处理结果
        System.out.println(result);
        //7.释放资源
        sqlSession.close();
        is.close();
    }
}

4. 注意事项

（1）在使用注解的时候，如果核心配置文件中进行了扫包，那就可以不需要mapper.xml文件
（2）如果核心配置文件中配置了扫包的方式，在不使用注解，而使用mapper.xml的时候，xml文件和mapper文件放在同一个目录下，并且命名要相同
（3）如果配置扫包，注解方式和mapper.xml方式不能同时存在在mapper包内

二. 注解实现多表开发【重要】

  实现复杂关系映射之前我们可以在映射文件中通过配置<resultMap>来实现，使用注解开发后，我们可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置
在这里插入图片描述
在这里插入图片描述

1. 一对一

1.1 CardMapper接口中查询全部

public interface CardMapper {
    //查询全部
    @Select("SELECT * FROM card")
    //指定一对一封装的结果
    /*
        property:被包含对象的变量名
        javaType:被包含对象的实际数据类型
        column:根据查询出的card表中的pid字段来查询person表
        one=@One()一对一固定写法
        select属性：指定调用哪个接口中的哪个方法（一定要使用接口的全类名）
     */
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "number",property = "number"),
            @Result(
            	property = "p",         //被包含对象的变量名
                javaType = Person.class,//被包含对象的实际数据类型
                column = "pid",         //根据查询出的card表中的pid字段来查询person表
                /*
                	one、@One 一对一固定写法
                    select属性：指定调用哪个接口中的哪个方法
               	*/
                one = @One(select = "com.itheima.one_to_one.PersonMapper.selectById")
            )
    })
    public abstract List<Card> selectAll();
}

1.2 PersonMaper接口中根据id查询

public interface PersonMapper {
  @Select("select * from person where id=#{id}")
  Person selectById(Integer id);
}

1.3 测试方法

/*
  测试一对一关系：查询所有card的信息，包括每个card对应的person信息
*/
@Test
public void selectAll() throws Exception{
	//1.加载核心配置文件
	InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
	//2.获取SqlSession工厂对象
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
	//3.通过工厂对象获取SqlSession对象
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	//4.获取CardMapper接口的实现类对象
	CardMapper mapper = sqlSession.getMapper(CardMapper.class);
	//5.调用实现类对象中的方法，接收结果
	List<Card> list = mapper.selectAll();
	//6.处理结果
	for (Card card : list) {
		System.out.println(card);
	}
	//7.释放资源
	sqlSession.close();
	is.close();
}

2. 一对多

2.1 ClassesMapper接口中查询全部

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

2.2 StudentMaper接口中根据id查询

public interface StudentMapper {
  @Select("select * from student where cid=#{cid}")
  List<Student> selectByCid(int cid);
}

2.3 测试方法

/*
  测试一对多关系：查询所有班级以及该班级的所有学生信息
*/
@Test
public void selectAll() throws Exception{
	//1.加载核心配置文件
	InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
	//2.获取SqlSession工厂对象
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
	//3.通过工厂对象获取SqlSession对象
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	//4.获取ClassesMapper接口的实现类对象
	ClassesMapper mapper = sqlSession.getMapper(ClassesMapper.class);
	//5.调用实现类对象中的方法，接收结果
	List<Classes> list = mapper.selectAll();
	//6.处理结果
	for (Classes cls : list) {
		System.out.println(cls.getId() + "," + cls.getName());
		List<Student> students = cls.getStudents();
		for (Student student : students) {
			System.out.println("\t" + student);
		}
	}
	//7.释放资源
	sqlSession.close();
	is.close();
}

3. 多对多

3.1 StudentMapper接口中查询全部

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

3.2 CourseMaper接口中根据id查询

public interface CourseMapper {
  @Select("select c.* from stu_cr sc,course c where sc.cid=c.id and sc.sid=#{sid}")
  public List<Course> selectBySid(Integer sid);
}

3.3 测试方法

/*
	测试多对多关系：查询所有学生及其选课信息
*/
@Test
public void selectAll() throws Exception{
	//1.加载核心配置文件
	InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
	//2.获取SqlSession工厂对象
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
	//3.通过工厂对象获取SqlSession对象
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	//4.获取StudentMapper接口的实现类对象
	StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
	//5.调用实现类对象中的方法，接收结果
	List<Student> list = mapper.selectAll();
	//6.处理结果
	for (Student student : list) {
		System.out.println(student.getId() + "," + student.getName() + "," + student.getAge());
		List<Course> courses = student.getCourses();
		for (Course cours : courses) {
			System.out.println("\t" + cours);
		}
	}
	//7.释放资源
	sqlSession.close();
	is.close();
}

三. 构建SQL【了解】

1. 提供类和方法返回Sql语句

public class ReturnSql {
    //定义方法，返回查询的sql语句
    public String getSelectAll() {
        return new SQL() {
            {
                SELECT("*");
                FROM("student");
            }
        }.toString();
    }
    
    //定义方法，返回新增的sql语句
    public String getInsert(Student stu) {
        return new SQL() {
            {
                INSERT_INTO("student");
                INTO_VALUES("#{id},#{name},#{age}");
            }
        }.toString();
    }

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

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

2. 在Mapper接口方法上替换

//利用@XxxxProvider来使用构建的sql
public interface StudentMapper {
    //查询全部
    //@Select("SELECT * FROM student")
    @SelectProvider(type = ReturnSql.class , method = "getSelectAll")
    public abstract List<Student> selectAll();

    //新增功能
    //@Insert("INSERT INTO student VALUES (#{id},#{name},#{age})")
    @InsertProvider(type = ReturnSql.class , method = "getInsert")
    public abstract Integer insert(Student stu);

    //修改功能
    //@Update("UPDATE student SET name=#{name},age=#{age} WHERE id=#{id}")
    @UpdateProvider(type = ReturnSql.class , method = "getUpdate")
    public abstract Integer update(Student stu);

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

3. 测试类测试

@Test
public void selectAll() throws Exception{
	//1.加载核心配置文件
	InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
	//2.获取SqlSession工厂对象
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
	//3.通过工厂对象获取SqlSession对象
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	//4.获取StudentMapper接口的实现类对象
	StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
	//5.调用实现类对象中的方法，接收结果
	List<Student> list = mapper.selectAll();
	//6.处理结果
	for (Student student : list) {
		System.out.println(student);
	}
	//7.释放资源
	sqlSession.close();
	is.close();
}

@Test
public void insert() throws Exception{
	//1.加载核心配置文件
	InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
	//2.获取SqlSession工厂对象
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
	//3.通过工厂对象获取SqlSession对象
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	//4.获取StudentMapper接口的实现类对象
	StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
	//5.调用实现类对象中的方法，接收结果
	Student stu = new Student(4,"赵六",26);
	Integer result = mapper.insert(stu);
	//6.处理结果
	System.out.println(result);
	//7.释放资源
	sqlSession.close();
	is.close();
}

@Test
public void update() throws Exception{
	//1.加载核心配置文件
	InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
	//2.获取SqlSession工厂对象
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
	//3.通过工厂对象获取SqlSession对象
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	//4.获取StudentMapper接口的实现类对象
	StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
	//5.调用实现类对象中的方法，接收结果
	Student stu = new Student(4,"赵六",36);
	Integer result = mapper.update(stu);
	//6.处理结果
	System.out.println(result);
	//7.释放资源
	sqlSession.close();
	is.close();
}

@Test
public void delete() throws Exception{
	//1.加载核心配置文件
	InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
	//2.获取SqlSession工厂对象
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
	//3.通过工厂对象获取SqlSession对象
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	//4.获取StudentMapper接口的实现类对象
	StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
	//5.调用实现类对象中的方法，接收结果
	Integer result = mapper.delete(4);
	//6.处理结果
	System.out.println(result);
	//7.释放资源
	sqlSession.close();
	is.close();
}

4. 构建动态sql

public class ReturnSql {
  public String getSelectCondition(Student stu){
        //select * from student where id=#{id} and name=#{name} and age=#{age}
        //创建初始化语句
        SQL sql = new SQL().SELECT("*").FROM("student");
        //判断
        if(stu!=null && stu.getId()!=null){
            sql.WHERE("id=#{id}");
        }
        if(stu!=null && stu.getName()!=null){
            sql.WHERE("name=#{name}"); //where方法会自动添加上and关键字
        }
        if(stu!=null && stu.getAge()!=null){
            sql.WHERE("age=#{age}"); //where方法会自动添加上and关键字
        }
        return sql.toString();
    }

  /*public String getSelectCondition(Student stu){
    //select * from student where id=#{id} and name=#{name} and age=#{age}
    //创建初始化语句
    StringBuilder sb=new StringBuilder("select * from student where 1=1");
    //判断
    if(stu!=null && stu.getId()!=null){
      sb.append(" and id=#{id}");
    }
    if(stu!=null && stu.getName()!=null){
      sb.append(" and name=#{name}");
    }
    if(stu!=null && stu.getAge()!=null){
      sb.append(" and age=#{age}");
    }
    return sb.toString();
  }*/
}

四. 案例改进

1. 项目环境搭建

（1）执行给定的sql，创建项目需要的数据库和表。
（2）创建动态web项目，项目名为mybatis_sms。
（3）将资料中mybatis_sms中的src目录和web目录中的所有内容复制到自己的mybatis_sms中
（4）修改config.properties中连接数据库的参数

2. mybatis环境搭建

（1）导入Mybatis的jar包和log4j的jar包
（2）导入核心配置问题和log4j配置文件和MyBatisUtils工具类
（3）修改核心配置文件中的数据库配置文件名称，标签中的路径也需要修改
（4）在StudentDao的方法上加上注解查询的sql语句
（5）在StudentServiceImpl中重写findAll()方法,使用接口代理的方式实现

3. 删除StudentDaoImpl,在StudentDao接口中使用注解配置CRUD

/*
    Dao层接口
 */
public interface StudentDao {
  //查询所有学生信息
  @Select("select * from student")
  public abstract ArrayList<Student> findAll();

  //条件查询，根据id获取学生信息
  @Select("select * from student where sid=#{id}")
  public abstract Student findById(Integer id);

  //新增学生信息
  @Insert("insert into student values (#{sid},#{name},#{age},#{birthday})")
  public abstract int insert(Student stu);

  //修改学生信息
  @Update("update student set name=#{name},age=#{age},birthday=#{birthday} where sid=#{sid}")
  public abstract int update(Student stu);

  //删除学生信息
  @Delete("delete from student where sid=#{sid}")
  public abstract int delete(Integer id);
}

4. 在utils包下导入编写好的MybatisUtils工具类

public class MyBatisUtils {
    //私有构造方法
    private MyBatisUtils(){}
    //声明工厂对象
    private static SqlSessionFactory sqlSessionFactory;
    //提供静态代码块,读取核心配置文件,并给工厂对象赋值
    static {
        try {
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("MyBatisConfig.xml"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //提供静态方法,获取SqlSession对象
    public  static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession(true);
    }
}

5. 在StudentServiceImpl中使用mybatis接口代理方式实现dao

public class StudentServiceImpl implements StudentService {
    @Override
    public List<Student> findAll() {
        //获SQLSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        //获取StudentDao接口的实现类对象
        StudentDao mapper = sqlSession.getMapper(StudentDao.class);
        //调用实现类对象响应的功能
        ArrayList<Student> list = mapper.findAll();
        //释放资源
        sqlSession.close();
        //返回结果
        return list;
    }
    @Override
    public Student findById(Integer sid) {
        //获SQLSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        //获取StudentDao接口的实现类对象
        StudentDao mapper = sqlSession.getMapper(StudentDao.class);
        //调用实现类对象响应的功能
        Student stu = mapper.findById(sid);
        //释放资源
        sqlSession.close();
        //返回结果
        return stu;
    }
    @Override
    public void save(Student student) {
        //获SQLSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        //获取StudentDao接口的实现类对象
        StudentDao mapper = sqlSession.getMapper(StudentDao.class);
        //调用实现类对象响应的功能
        mapper.insert(student);
        //释放资源
        sqlSession.close();
    }
    @Override
    public void update(Student student) {
        //获SQLSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        //获取StudentDao接口的实现类对象
        StudentDao mapper = sqlSession.getMapper(StudentDao.class);
        //调用实现类对象响应的功能
        mapper.update(student);
        //释放资源
        sqlSession.close();
    }
    @Override
    public void delete(Integer sid) {
        //获SQLSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        //获取StudentDao接口的实现类对象
        StudentDao mapper = sqlSession.getMapper(StudentDao.class);
        //调用实现类对象响应的功能
        mapper.delete(sid);
        //释放资源
        sqlSession.close();
    }
}
挨踢农民工dsh
关注
专栏目录
MyBatis注解方式批量插入操作
didui0897的博客
01-28 84
@Insert({ "<script>", "insert into table_name(column1, column2, column3) values ", "<foreach collection='testLists' item='item' index='index' separator=','>", "(#{item.实体属性1}, #{item....
mybatis注解方式写入复杂sql
zebbyte的博客
10-21 2497
mybatis是持久层框架，用于简化JDBC,具体就不作复述了。 这里重点阐述下mybatis注解的方式对比传统jdbc完成复杂sql编写。 注解方式是mybatis的独有的，关键的几个@Select @Insert @Delete@Update都是ibatis下的，如@Select 注解的方式极大地简化了sql的编写过程，如在接口文件里 对比JDBC标签写法 会发现能省去id,和resultMap的配置，代码也易读性也增强了不少。 接下来我要介绍下面各种情况的sql写法， 1.首先是基础sql，如上
java注解 sql_Java注解详解
weixin_28882565的博客
02-16 1157
在使用SpringBoot作为Web敏捷开发的框架之后，SpringBoot除了自动装配配置的便捷之外，在很多时候需要基于注解来开发。注解不仅增加了代码的可读性，还增加了开发的速度。这篇文章主要讲述Java 注解。元注解元注解用于注解其他注解的。Java 5.0定义了4个标准的元注解，如下：@Target@Retention@DocumentedInherited现在来说说这四个元注解有什么作用。...
MyBatis笔记(1)——MyBatis初体验（纯Java项目创建MyBatis）
renaway的博客
06-05 3532
    MyBatis是支持普通SQL查询、存储过程和高级映射的优秀持久层框架。它是对JDBC的再封装，几乎避免所有的JDBC代码和参数的手工设置以及对结果集的检索。MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO(Plain Old Java Objects, 普通的Java对象)映射成数据库中的记录。   下面是Mybatis官网的介绍:        ...
JavaWeb自我学习——MaBatis参数传递以及注解开发
一名不想学习的未来程序猿。
04-02 552
目录 一.参数传递 1.单个参数: 2.多个参数:封装为Map集合， 3.总结： 二.注解开发 1.形式： 2.注解: 3.提示： 一.参数传递 MyBatis 接口方法中可以接收各种各样的参数，MyBatis底层对于这些参数进行不同的封装处理方式。 MyBatis提供了ParamNameResolver 类来进行参数封装 。 1.单个参数: 1. POJ0类型:直按使用，属性名和参数占位符名称一致 2. Map集合:直按使用,键名和参数占位符名称一划| 3. Col..
MyBatis-学习笔记12【12.Mybatis注解开发】
upward
02-08 438
MyBatis-学习笔记12【12.Mybatis注解开发】
使用mybatis-plus如何实现零sql做到多表查询
小王同学的博客
12-21 2202
使用mybatis-plus如何实现零sql做到多表查询 在很多时候我们使用mybatis时我们会发现mapper文件写起来太麻烦了，所以现在很多基于mybatis进行封装的框架，这些框架的目的是将一些普通的增删改查帮我们封装好，我们直接继承别人提供的接口就能调用一些基本的增删改查方法了，我们发现在使用的时候这些方法只能实现简单的单表操作，其实框架也支持多表操作，只是需要我们做一些额外的配置，下面我简单的实现一下使用mybatis-plus进行多表查询 我就拿我正在做的一个项目为例子 表格之间的关系是订单表
MyBatis-学习笔记04【04.自定义Mybatis框架基于注解开发】
upward
12-31 450
MyBatis-学习笔记04【04.自定义Mybatis框架基于注解开发】
MyBatis-学习笔记09【09.Mybatis的多表操作】
upward
02-08 1026
MyBatis-学习笔记09【09.Mybatis的多表操作】
FourDay-MyBatis（基于注解的学生管理程序）的源代码
11-12
【标题】"FourDay-MyBatis（基于注解的学生管理程序）的源代码" 提供了一个关于使用MyBatis框架构建的Java学生管理系统。这个系统利用MyBatis的注解方式来简化数据库操作，降低了数据库层与业务逻辑层之间的耦合度。...
sky-take-out阶段性工程代码（day04-套餐之分页查询、新增套餐、修改套餐、启用禁用套餐）
11-05
综上所述，"sky-take-out"项目展示了Java Spring Boot环境下的Web应用开发，特别是套餐管理这一核心功能的实现，涵盖了数据查询、增删改查的基本操作，同时也暴露出前后端协同开发中的挑战。通过深入理解和实践这些...
java-ee-ssm-day-two-master.zip
06-28
SSM框架的整合是Java EE开发中的常见实践，它将Spring的管理能力、Spring MVC的Web处理能力和MyBatis的数据访问能力结合在一起，为开发者提供了强大且灵活的工具。 1. **项目结构**：在`java-ee-ssm-day-two-master...
day07-mybatis实现动态sql、多表查询和注解开发
weixin_51297617的博客
10-08 537
typora-copy-images-to: img day07-mybatis实现动态sql、多表查询和注解开发 学习目标 1. 掌握sqlMapConfig.xml中常用标签 2. 掌握mybatis框架在DAO层的开发 3. 能够完成单表的CRUD操作 4. 掌握mybatis框架的输入输出映射 5. 掌握MyBatis动态SQL 回顾 1、数据库： DataBase-数据存储 2、数据操作：CRUD-增删改查 【1】使用MySQL默认的客户端： 输入sql脚本操作数据 【2】JDBC：ja.
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 5483
【代码】MybatisPlus的LambdaQueryWrapper用法。
JAVA-01-变量
LJH_laura_li的博客
11-08 261
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 134
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
最新发布
chusheng1840的博客
11-09 486
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 317
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 989
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
Mybatis逆向工程在Java Web项目中的应用实例
资源摘要信息:"mybatis逆向工程的Java Web项目示例" 知识点概述： ...通过对该项目的分析和学习，可以加深对MyBatis逆向工程的理解，并掌握如何在实际的Java Web项目中应用逆向工程来提升开发效率。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值