4.1-Mybatis

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量98 收藏
点赞数
分类专栏： java学习之路 文章标签： mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44755621/article/details/119547394
版权

Mybatis

1.简介

1.1 mybatis

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。

获取

  • maven
  • github

1.2 持久层

持久化：将程序数据在持久状态和瞬时状态间转换的机制。通俗的讲，就是瞬时数据（比如内存中的数据，是不能永久保存的）持久化为持久数据（比如持久化至数据库中，能够长久保存）。

持久层：完成持久化工作的代码块

2.第一个程序

2.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 values(1,'name','pwd');

新建项目（IDEA）

  1. 新建maven项目
  2. 删除 src 目录
  3. 导入依赖

2.2 新建模块（基于上述项目, maven）

  • 配置mybatis
    新建 /src/resources/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="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="cqu/ma/dao/UserMapper.xml"/>
    </mappers>
</configuration>

  • 编写工具类 (获取 SqlSession 对象)

    package cqu.ma.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;

public class MybatisUtil {

    private static SqlSessionFactory sqlSessionFactory;

    static{

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

    //通过 sqlSessionFactory 获取 sqlSession 对象
    //SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

2.3 编写代码

  1. pojo.User (简单类对于数据库 user表)

    package cqu.ma.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;
    }

    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 getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString(){
        return "user{"
                +this.id
                +","
                +this.name
                +","
                +this.pwd
                +"}";
    }
}

  2. dao.UserDao (dao 接口)

    package cqu.ma.dao;

import cqu.ma.pojo.User;

import java.util.List;

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

  3. dao/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">
<!--namespace 绑定一个对应的 DAO/Mapper 接口-->
<mapper namespace="cqu.ma.dao.UserDao">
    <!--id=方法名-->
    <select id="getUserList" resultType="cqu.ma.pojo.User">
        select * from mybatis.user
    </select>
</mapper>

2.4 测试

注意：

  • mybatis-config.xml 中需要注册 对应的mapper.xml

  • maven约定大于配置，可能写的配置文件无法导出
    解决：在 pom.xml 中添加

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

测试代码

package cqu.ma.dao;

import cqu.ma.pojo.User;
import cqu.ma.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){
        //1.获取 sqlSession
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        //2.执行 sql
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();

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

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

2.5 总结

  1. mybatis-config.xml 核心配置文件
  2. 由该配置文件创建一个 SqlSessionFactory 对象
  3. 由SqlSessionFactory 对象 获取 SqlSession 对象
  4. dao接口类，mapper.xml 代替 dao接口实现类，并在 mabatis-config.xml中注册该 mapper.xml
  5. 测试

3. CRUD

dao/mapper

package cqu.ma.dao;

import cqu.ma.pojo.User;

import java.util.List;

public interface UserMapper {
    public List<User> getUserList();

    public User getUserById(int id);

    public int addUser(User user);

    public int updateUser(User user);

    public int deleteUser(int id);
}

mapper.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">
<!--namespace 绑定一个对应的DAO/Mapper接口-->
<mapper namespace="cqu.ma.dao.UserMapper">
    <!-- id=方法名 -->
    <select id="getUserList" resultType="cqu.ma.pojo.User">
        select * from mybatis.user
    </select>
    
    <select id="getUserById" parameterType="int" resultType="cqu.ma.pojo.User">
        select * from mybatis.user where id = #{id}
    </select>
    
    <!--对象中的属性可以直接取出来-->
    <insert id="addUser" parameterType="cqu.ma.pojo.User">
        insert into mybatis.user(id,name,pwd) values(#{id},#{name},#{pwd})
    </insert>
    
    <update id="updateUser" parameterType="cqu.ma.pojo.User">
        update mybatis.user set name=#{name}, pwd=#{pwd} where id=#{id}
    </update>

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

test

package cqu.ma.dao;

import cqu.ma.pojo.User;
import cqu.ma.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){
        //1.获取 sqlSession
        SqlSession sqlSession = MybatisUtil.getSqlSession();

        //2.执行 sql

        //方式1：getMapper
        UserMapper userDao = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userDao.getUserList();

        //方式2：
        //List<User> userList = sqlSession.selectList("cqu.ma.dao.UserDao.getUserList");

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

        //3.关闭
        sqlSession.close();
    }
    @Test
    public void getUserById(){
        SqlSession session = MybatisUtil.getSqlSession();

        UserMapper mapper = session.getMapper(UserMapper.class);

        User user = mapper.getUserById(1);

        System.out.println(user);

        session.close();
    }

    @Test
    public void addUser(){
        //增删改需要提交事务
        SqlSession session = MybatisUtil.getSqlSession();

        UserMapper mapper = session.getMapper(UserMapper.class);

        int n = mapper.addUser(new User(3,"用户3","333"));
        System.out.println(n);

        //提交事务
        session.commit();

        session.close();
    }
    @Test
    public void updateUser(){
        SqlSession session = MybatisUtil.getSqlSession();

        UserMapper mapper = session.getMapper(UserMapper.class);

        int n = mapper.updateUser(new User(3,"新用户3","11111"));
        System.out.println(n);

        session.commit();
        session.close();
    }
    @Test
    public void deleteUser(){
        SqlSession session = MybatisUtil.getSqlSession();

        UserMapper mapper = session.getMapper(UserMapper.class);

        int n = mapper.deleteUser(3);
        System.out.println(n);

        session.commit();
        session.close();
    }
}

模糊查询

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

4.配置解析

4.1 核心配置文件

4.2 environments

MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。

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

4.3 properties

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

4.4 类型别名

<typeAliases>
        <typeAlias type="cqu.ma.pojo.User" alias="User"></typeAlias>
</typeAliases>

已有的

别名映射的类型
_bytebyte
_longlong
_shortshort
_intint
_integerint
_doubledouble
_floatfloat
_booleanboolean
stringString
byteByte
longLong
shortShort
intInteger
integerInteger
doubleDouble
floatFloat
booleanBoolean
dateDate
decimalBigDecimal
bigdecimalBigDecimal
objectObject
mapMap
hashmapHashMap
listList
arraylistArrayList
collectionCollection
iteratorIterator

5.resultMap

解决java类中属性名与数据库表中字段名不一致问题

<?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="cqu.ma.dao.UserMapper">
    <!--id 名字-->
    <resultMap id="UserMap" type="User">
        <!--column=数据库表中字段名，property=实体类中属性名-->
        <result column="pwd" property="password"></result>
    </resultMap>
    
    <!-- id=方法名 -->
    <select id="getUserList" resultMap="UserMap">
        select * from mybatis.user
    </select>
    <select id="getUserById" parameterType="int" resultType="cqu.ma.pojo.User">
        select * from mybatis.user where id = #{id}
    </select>

</mapper>

6.日志

6.1 日志工厂

settings

logImpl指定 MyBatis 所用日志的具体实现，未指定时将自动查找。SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING

STDOUT_LOGGING 标准日志工厂

6.2 Log4j

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等

  1. 导入

    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

  2. log4j.properties

    #将等级为DEBUG的日志信息输出到console和file
log4j.rootLogger=DEBUG,console,file

#控制台 console
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

#文件 file
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/ma.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.slq.ResultSet=DEBUG
log4j.logger.java.sql.PrepareStatement=DEBUG

  3. mybatis-config.xml

    <settings>
<!--        <setting name="logImpl" value="STDOUT_LOGGING"/>-->
        <setting name="logImpl" value="LOG4J"/>
    </settings>

代码中使用Log4j

package cqu.ma;

import org.apache.log4j.Logger;
import org.junit.Test;

public class Log4jTest {
    //参数为当前类 class 对象
    static Logger logger = Logger.getLogger(Log4jTest.class);

    @Test
    public void test(){
        logger.info("info: test");
        logger.debug("debug:test");
        logger.error("error:test");
    }
}

7.分页

select * from `user` limit startIndex,pageSize

8.使用注解开发

适用于简单语句，不用编写 mapper.xml

package cqu.ma.dao;

import cqu.ma.pojo.User;
import org.apache.ibatis.annotations.Select;

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

public interface UserMapper {
    @Select("select * from mybatis.user")
    public List<User> getUserList();

}

mybatis-config.xml

    <mappers>
<!--        <mapper resource="cqu/ma/dao/UserMapper.xml"/>-->
        <!--绑定接口-->
        <mapper class="cqu.ma.dao.UserMapper"></mapper>
    </mappers>

9.Lombok

  1. IDEA 安装 lombok (IDEA2021 默认已安装)
  2. 导入lombok依赖
  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
@var
experimental @var
@UtilityClass

@Data : 无参构造，getter，setter，toString，hashCode，equals
@AllArgsConstructor() //显示定义有参构造，若需要无参构造仍需要显示定义
@NoArgsConstructor()

10.多对一

package cqu.ma.pojo;

import lombok.Data;

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

    private Teacher teacher;
}

package cqu.ma.pojo;

import lombok.Data;

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

按照查询嵌套处理

<?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="cqu.ma.dao.StudentMapper">
    <resultMap id="StudentMap" type="cqu.ma.pojo.Student">
        <result column="id" property="id"></result>
        <result column="name" property="name"></result>
        <!--复杂属性
            对象 : association
            集合 : collection
        -->
        <association property="teacher" column="tid" javaType="cqu.ma.pojo.Teacher" select="getTeacher"></association>
    </resultMap>

    <select id="getStudents" resultMap="StudentMap">
        select * from student
    </select>
    <select id="getTeacher" resultType="cqu.ma.pojo.Teacher">
        select * from teacher where id=#{id}
    </select>
</mapper>

按照结果嵌套处理

<select id="getStudents2" resultMap="StudentMap2">
    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="StudentMap2" type="cqu.ma.pojo.Student">
    <result property="id" column="sid"></result>
    <result property="name" column="sname"></result>
    <association property="teacher" javaType="cqu.ma.pojo.Teacher">
        <result property="id" column="tid"></result>
        <result property="name" column="tname"></result>
    </association>
</resultMap>

11.一对多

package cqu.ma.pojo;

import lombok.Data;

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

    private int tid;
}

package cqu.ma.pojo;

import lombok.Data;

import java.util.List;

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

    private List<Student> students;
}

<?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="cqu.ma.dao.TeacherMapper">
    <!--按结果嵌套-->
    <select id="getTeacher" resultMap="TeacherMap">
        select s.id sid, s.name sname, t.name tname, t.id tid
        from teacher t, student s
        where s.tid=t.id and t.id=#{tid}
    </select>

    <resultMap id="TeacherMap" type="cqu.ma.pojo.Teacher">
        <result property="id" column="tid"></result>
        <result property="name" column="tname"></result>
        <!--复杂属性-->
        <collection property="students" ofType="cqu.ma.pojo.Student">
            <result property="id" column="sid"></result>
            <result property="name" column="sname"></result>
            <result property="tid" column="tid"></result>
        </collection>
    </resultMap>


    <!--按照查询嵌套-->
    <select id="getTeacher2" resultMap="TeacherMap2">
        select * from teacher where id=#{tid}
    </select>

    <resultMap id="TeacherMap2" type="cqu.ma.pojo.Teacher">
        <result property="id" column="id"></result>
        <collection property="students" column="id" javaType="ArrayList" ofType="cqu.ma.pojo.Student" select="getStudentsByTid"></collection>
    </resultMap>
    <select id="getStudentsByTid" resultType="cqu.ma.pojo.Student">
        select * from student where tid=#{tid}
    </select>

</mapper>

小结

  1. association 多对一
  2. collection 一对多
  3. javaType 指定实体类中属性类型
  4. ofType 指定泛型约束类型（如集合范型参数）

12.动态sql

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

使用动态 SQL 并非一件易事，但借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言，MyBatis 显著地提升了这一特性的易用性。

如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。

  • if
  • choose (when, otherwise)
  • trim (where, set)
  • foreach

IF

package cqu.ma.dao;

import cqu.ma.pojo.Blog;

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

public interface BlogMapper {

    public int addBlog(Blog blog);

    public List<Blog> getBlogsIF(Map map);
}

<?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="cqu.ma.dao.BlogMapper">
    <insert id="addBlog" parameterType="cqu.ma.pojo.Blog">
        insert into blog(id,title,author,create_time,views)
        values(#{id},#{title},#{author},#{createTime},#{views})
    </insert>

    <select id="getBlogsIF" parameterType="map" resultType="cqu.ma.pojo.Blog">
        select * from blog where 1=1
        <if test="title != null">
            and title=#{title}
        </if>
        <if test="author != null">
            and author=#{author}
        </if>
    </select>

</mapper>

@Test
    public void getBlogsIF(){
        SqlSession session = MybatisUtil.getSqlSession();
        BlogMapper mapper = session.getMapper(BlogMapper.class);
        Map<String,String> map = new HashMap<>();
//        map.put("title","t1");
        map.put("author","a1");
        List<Blog> blogs = mapper.getBlogsIF(map);

        for (Blog blog : blogs) {
            System.out.println(blog);
        }

        session.close();
    }

choose

类似 switch case

<select id="getBlogsChoose" parameterType="map" resultType="cqu.ma.pojo.Blog">
        select * from blog
        <where>
            <choose>
                <when test="title!=null">
                    title=#{title}
                </when>
                <when test="author!=null">
                    author=#{author}
                </when>
                <otherwise>
                    views=#{views}
                </otherwise>
            </choose>
        </where>
    </select>

trim (where, set)

where

select * from blog
<where>
	<if test="title!=null">
    	title=#{title}
    </if>
    <if test="author!=null">
    	and author=#{author}
    </if>
</where>

<!-- where 标签 处理条件 -->

set

    <update id="updateBlogSET" parameterType="map">
        update blog
        <set>
            <if test="title!=null">
                title=#{title},
            </if>
            <if test="author!=null">
                author=#{author}
            </if>
        </set>
        where id=#{id}
    </update>

foreach

    <select id="getBlogsForeach" parameterType="map" resultType="cqu.ma.pojo.Blog">
        select * from blog
        <where>
            <!--collection 集合名字 item 取出每个元素 命名w-->
            <foreach collection="views" item="view" open="(" close=")" separator="or">
                views=#{view}
            </foreach>
        </where>
    </select>

@Test
    public void getBlogsForeach(){
        SqlSession session = MybatisUtil.getSqlSession();
        BlogMapper mapper = session.getMapper(BlogMapper.class);
        Map<String,Object> map = new HashMap<>();
        List<Integer> views = new ArrayList<>();
        views.add(0);
        views.add(9);
        map.put("views",views);
        List<Blog> blogs = mapper.getBlogsForeach(map);

        for (Blog blog : blogs) {
            System.out.println(blog);
        }

        session.close();
    }

sql片段

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


    <select id="getBlogsIF" parameterType="map" resultType="cqu.ma.pojo.Blog">
        select * from blog where 1=1
        <include refid="if-title-author"></include>
    </select>
_auroras_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring4.1+mybatis+CXF最新webservice DEMO
01-27
在本"spring4.1+mybatis+CXF最新webservice DEMO"中，这三大组件共同构建了一个完整的Web服务解决方案。Spring作为核心框架，负责管理和协调各个组件，提供依赖注入和AOP（面向切面编程）等功能。MyBatis作为数据...
spring-boot-starter-mybatis-spring-boot-1.2.2.zip
04-19
<artifactId>mybatis-spring-boot-starter <version>1.2.2 ``` 1.3 配置文件：在application.properties或application.yml中设置数据源和MyBatis的相关配置，例如数据源类型、数据库连接信息、Mapper扫描路径等。...
spring mvc 4.1.5+mybatis 3.2.6+ maven
martin_yl的专栏
07-22 799
spring mvc 4.1.5+mybatis 3.2.6+ maven搭建开发环境 eclipse + MySql5.6 + JDK1.8 + tomcat7使用Maven下载Jar包 pom.xml如下：<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSch
MyBatis 源码分析 - MyBatis入门
2401_84002803的博客
04-30 558
JDBCJDBC 作为 Java 平台的数据库访问规范，它仅提供一种访问数据库的能力。使用步骤：加载数据库驱动，创建数据库连接对象，创建 SQL 执行语句对象，执行 SQL 和处理结果集。缺点： JDBC 流程繁琐；拼接 SQL 可能会导致 SQL 出错；将 SQL 和 Java 代码混在一起，会降低代码的可读性，不利于维护；执行结果的处理麻烦；用户还需要手动管理数据库连接，开始要手动获取数据库连接。使用好后，又要手动关闭数据库连接。
java-mybatis
manyi8634的博客
07-17 847
4.2 配置MyBatis 五、MyBatis的开发步骤 5.1 创建表 5.2 定义实体 5.3 编写映射文件 5.4 注册Mapper 5.5 代理实现Mapper过程 六、细节补充 6.1 properties配置文件 6.2 类型别名 6.3 加载映射文件 6.4 配置日志信息 七、MyBatis的CRUD操作(重点) 7.1 查询 7.1.1 参数序号(了解) 7.1.2 注解（推荐） 7.1.3 Map参数绑定 7.1.4 通过
JavaWeb-MyBatis
MMF博客园
01-05 1221
JavaWeb-MyBatis
day09-Mybatis
yirenyuan的博客
03-16 893
一、MyBatis 基础操作 | 二、MyBatis 的 XML 配置文件 | 三、MyBatis 动态 SQL |
4.1javaEE-Mybatis-oracle基于WEB的仓库管理系统的设计与实现(源码+数据库sql+lun文+视频齐全)
03-10
4.1javaEE_Mybatis_oracle基于WEB的仓库管理系统的设计与实现(源码+数据库sql+lun文+视频齐全) 基于WEB的仓库管理系统的源代码和论文 基于WEB的仓库管理系统主要用于实现仓库的出入库管理，基本功能包括：入库模块、...
高级软件人才培训专家-day08-Mybatis入门
03-10
<artifactId>mybatis-spring-boot-starter <version>2.3.0 <!-- MySQL 驱动包依赖 --> <groupId>mysql <artifactId>mysql-connector-java <scope>runtime <!-- Spring 单元测试 --> <groupId>org....
基于springboot社区疫情防控管理系统代码-java - springboot - mybatis-代码
01-11
基于springboot社区疫情防控管理系统代码-java - springboot - mybatis-代码-源码-社区疫情防控管理系统 1、技术栈：微信小程序，springboot，uniapp，vue，ajax，maven，mysql，MyBatisPlus 2、系统的实现 用户...
golang 接口
m0_70982551的博客
07-24 872
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 460
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 566
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 550
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 346
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 398
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 839
java、数据类型、循环、选择等
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 168
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 853
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
Struts2.3 + Spring4.1 + MyBatis3.2 整合教程：项目技术准备与步骤
5. MyBatis-Spring：这是一个MyBatis的扩展，提供了与Spring框架无缝集成的功能。 接下来，文档指导你进行以下步骤： 2.1 导入必要的JAR包：你需要将上述下载的JAR文件添加到项目的类路径（classpath）中，以便在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值