使用Mybatis完成CRUD

最新推荐文章于 2022-04-24 10:32:09 发布
最新推荐文章于 2022-04-24 10:32:09 发布
阅读量202 收藏
点赞数
文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HRK0909/article/details/105208967
版权

目录结构

在这里插入图片描述

配置pom.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>com.hurongkun</groupId>
    <artifactId>mybatis_CRUD</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.4</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>

    </dependencies>
</project>

配置SqlMapConfig.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="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/eesy_mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="970323"/>
            </dataSource>
        </environment>
    </environments>
    <!--配置映射文件的位置-->
    <mappers>
        <mapper resource="com/hurongkun/dao/IUserDao.xml"></mapper>
    </mappers>
</configuration>

在工程里导入log4j.properties文件

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=g:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

创建User实体类要求属性名对应数据库中的表列名

package com.hurongkun.domain;
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable {
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", address='" + address + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                '}';
    }
}

创建QueryVo实体类，要求包含一个User类型的属性。用于测试OGNL。

package com.hurongkun.domain;
public class QueryVo {
    private User user;
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
}

编写DAO接口

package com.hurongkun.dao;
import com.hurongkun.domain.QueryVo;
import com.hurongkun.domain.User;
import java.util.List;

/**
 * 用户的持久层接口
 */
public interface IUserDao {
    /**
     * 查询所有用户
     * @return
     */
    List<User> findAll();

    /**
     * 保存方法
     * @param user
     */
    void saveUser(User user);

    /**
     * 更新用户
     * @param user
     */
    void updateUser(User user);

    /**
     * 根据id删除用户
     * @param id
     */
    void deleteUser(Integer id);

    /**
     * 根据id查询用户信息
     * @param id
     * @return
     */
    User findById(Integer id);

    /**
     * 根据用户名模糊查询用户信息
     * @param username
     * @return
     */
    List<User> findByName(String username);

    /**
     * 查询总用户数
     * @return
     */
    int findTotal();

    /**
     * 查询条件放入QueryVo的user属性中
     * 根据QueryVo中的条件查询用户
     *
     * @param vo
     * @return
     */
    List<User> findUserByVo(QueryVo vo);
}

根据DAO编写相应的映射配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hurongkun.dao.IUserDao">

    <!--
        List<User> findAll();
        查询所有用户的方法
    -->
    <select id="findAll" resultType="com.hurongkun.domain.User">
        select * from user;
    </select>
    <!--
        void saveUser(User user);
        保存用户
        parameterType:参数的类型
        #{}：括号中的内容需要根据实体类中的属性来提供，也就是和属性名相一致（在右键生成的get、set方法情况下）
        注意:如果不是通过右键生成的get、set方法，那括号里应该填get方法后边的这个名称
        例如：get方法是getUsername(),那么括号里应该填Username。
        keyProperty:id在实体类的属性名称
        keyColumn：id的列名，指的是在数据库中表里面的id的列名
        order：什么时候执行获取id的操作  AFTER：在插入之后
    -->
    <insert id="saveUser" parameterType="com.hurongkun.domain.User">
        <!--配置插入操作后，获取插入数据的id -->
        <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday});
    </insert>

    <!--
        void updateUser(User user);
        更新用户
    -->
    <update id="updateUser" parameterType="com.hurongkun.domain.User">
        update user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id = #{id}
    </update>

    <!--
        void deleteUser(Integer id);
        删除用户
        当Dao的方法（void deleteUser(Integer id);）中只有一个Integer类型的参数而且是只有一个参数，
        在这种情况下只需要写一个占位符就行即id={id}，占位符的内容是没有任何要求的。可以是id12312...
        delete from user where id ={id}
    -->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id = #{uid}
    </delete>

    <!--
        User findById(Integer id);
        根据id查询用户
       这里需要写resultType，是Dao方法的返回值是一个User对象
   -->

    <select id="findById" parameterType="java.lang.Integer" resultType="com.hurongkun.domain.User">
        select * from user where id=#{id};
    </select>

    <!--
         List<User> findByName(String username);
        根据用户名模糊查询用户信息
        模糊查询的另一种写法，不写在测试类中，而写在映射配置文件中
        select * from user where username like '%${value}%'
    -->
    <select id="findByName" parameterType="String" resultType="com.hurongkun.domain.User">
        <!--select * from user where username like '%${value}%'-->
        select * from user where username like #{name}
    </select>

    <!--
        int findTotal();
        获取用户总记录条数
    -->
    <select id="findTotal" resultType="int">
        select count(id) from user
    </select>

    <!--
        List<User> findUserByVo(QueryVo vo);
        根据QueryVo的条件查询用户
         mybatis中为什么能直接写username，而不用user.呢
         因为在parameterType中已经提供了属性所属的类，所以此时不需要写类，而是直接写属性名。
         例子：vo对象包装了一个user对象，user里有一个username属性。直接写user.username。不用管包装对象vo
         一句话：不管包装，只看内容
    -->
    <select id="findUserByVo" parameterType="com.hurongkun.domain.QueryVo" resultType="com.hurongkun.domain.User">
        select * from user where username like #{user.username}
    </select>

</mapper>

在测试类中运行查看结果

public class MybatisTest {
    //把这些变量定义出来，后续不用再定义可以直接用
    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;
    @Before //用于在测试方法执行之前执行
    public void init()throws Exception{
        //1.读取配置文件生成字节输入流,使用getResourceAsStream时，抛出异常即可。
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession();
        //4.获取Dao的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }
    @After//用于在测试方法执行之后执行
    public void destory()throws Exception{
        //提交事务
        sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }
    /**
     * 测试查询所有用户
     * List<User> findAll();
     */
    @Test
    public void testFindAll(){

        //5.执行查询所有用户方法
        List<User> users = userDao.findAll();
        for(User user:users){
            System.out.println(user);
        }
    }

    /**
     * 测试保存操作
     * void saveUser(User user);
     */
    @Test
    public void testSaveUser()  {
        User user = new User();
        user.setUsername("mybatis last insert");
        user.setAddress("上海");
        user.setSex("男");
        user.setBirthday(new Date());
        System.out.println("保存操作之前"+user);
        //5.执行保存方法
        userDao.saveUser(user);
        /*提交事务，不写这一句事务会回滚，无法提交,同样
        也可以将这行代码放入destory方法的close()方法之前保证事务提交*/
        //sqlSession.commit();
        System.out.println("保存操作之后"+user);
    }

    /**
     * 测试更新
     * void updateUser(User user);
     */
    @Test
    public void testUpdateUser()  {
        User user = new User();
        user.setId(41);
        user.setUsername("mybatis updateUser");
        user.setAddress("南昌");
        user.setSex("女");
        user.setBirthday(new Date());
        //5.执行更新方法
        userDao.updateUser(user);
    }

    /**
     * 测试删除
     * void deleteUser(Integer id);
     */
    @Test
    public void testDeleteUser() throws IOException {

        //5.执行删除方法
        userDao.deleteUser(49);
    }

    /**
     * 测试根据id查询用户
     * User findById(Integer id);
     * @throws IOException
     */
    @Test
    public void testFindById() throws IOException {

        //5.根据id查询用户方法
        User user = userDao.findById(43);
        System.out.println(user);
    }

    /**
     * 测试根据用户名查询用户信息
     * List<User> findByName(String username);
     * @throws IOException
     */
    @Test
    public void testFindByName() throws IOException {

        //5.执行根据用户名模糊查询方法
        List <User> users = userDao.findByName("%张%");//查询包含张字的人
        //List <User> users = userDao.findByName("张"); 在配置文件中写的模糊查询
        /*这里需要写%进行模糊查询*/
        for(User user:users){
            System.out.println(user);
        }
    }

    /**
     * 测试查询用户总记录条数
     * int findTotal();
     */
    @Test
    public void testFindTotal()  {
        int count;
        //5.执行查询用户总记录条数
       count =  userDao.findTotal();
       System.out.println(count);

    }

    /**
     * 测试使用QueryVo作为查询条件
     * List<User> findUserByVo(QueryVo vo);
     */
    @Test
    public void testFindUserByVo() throws IOException {

        //5.执行使用QueryVo作为查询条件
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUsername("%张%");//设置user对象的username为"%张%"
        vo.setUser(user);//把名字为"%张%"的用户放入Vo对象。
        List <User> users = userDao.findUserByVo(vo);
        //这时候传入的参数实际上则是Vo对象里user对象的用户名"%张%"
        /**
         * OGNL表达式
         * Object   Graphic  Navigation  Language
         * 对象        图              导航            语言
         * 它是通过对象的取值方法来获取数据，根据对象就可以直接点出属性名。在写法上把get给省略了。
         * 比如：我们获取用户的名称
         * 	类中的写法：user.getUsername();
         * 	OGNL表达式写法：user.username
         * mybatis中为什么能直接写username，而不用user.呢
         * 因为在parameterType中已经提供了属性所属的类，所以此时不需要写类，而是直接写属性名。
         * 例子：vo对象包装了一个user对象，user里有一个username属性。直接写user.username。不用管包装对象vo
         * 一句话：不管包装，只看内容。
         */
        for(User u:users){
            System.out.println(u);
        }
    }
}

解决实体类属性名和数据库列名不对应的两种方式：

如果实体类属性名和数据库列名不对应，就无法匹配，就无法实现封装。
假设：User实体类中的属性名分别是：userId、userName、userAddress、userSex、userBirthday
与之对应数据库表的列名是：id、username、address、sex、birthday。那么怎么让他们对应起来呢？
方式一：在映射配置文件中的SQL语句里起别名如下：

<select id="findAll" resultType="com.hurongkun.domain.User">
        select id as userId，username as userName,address as userAddress,sex as userSex,birthday as userBirthday from user
</select>

优点：执行效率高
缺点：需要一个个写SQL，开发效率低

方式二：在映射配置文件中使用resultMap配置查询结果的列名和实体类的属性名的对应关系

<resultMap id="userMap" type="com.hurongkun.domain.User">
	//主键字段的对应
	<id property="userId" column="id"></id>
	//非主键字段的对应
	<result property="userName"column="username"></result>
	<result property="userAddress"column="address"></result>
	<result property="userSex"column="sex"></result>
	<result property="userBirthday"column="birthday"></result>
</resultMap>

1.resultMap的id是自定定义的一个唯一标识。
2.type：所对应的实体类
3.property:实体类中的属性名
4.column：数据库中表的列名
注意：配置完成后如果要使用这种对应，resultType就不能再用了，而应换成resultMap，而resultMap的值，就是刚开始配置时自己定义的resultMap的id名。
例子：

<select id="findAll" resultMap="userMap">
        select * from user;
</select>

优点：开发效率高，更改起来方便。
缺点：执行效率低。

Mybatis增删改查心得总结：

1.Dao接口的写法
1.分析是做什么操作判断有没有返回值
有查询就有返回值，没查询就没有返回值。有些增删改操作后需要查看这种也算有查询。
2.确定返回值是多个还是单个
就是查询的结果是多个还是单个，多个就用List<>包起来，单个就直接确定返回值类型。
3.确定返回值类型
返回值的类型取决于你要查的是什么信息，查字段，字段是什么类型返回值就是什么类型。
查的信息包含了所有字段，那返回值类型就是与数据库表对应的实体类。
例如：查的是用户信息，那返回值就是User类。查的是姓名：返回值就是String
4.参数是什么
问一个问题，需要给我什么信息才能执行操作。
添加操作：必须要告诉我添加哪些字段，这些字段构成了一维表所对应的实体类
更改操作：也需要告诉我更改哪些字段，这些字段构成了一维表所对应的实体类
删除：条件删除，所用的条件就是参数。
查询：条件查询，所用的条件就是参数
什么都不需要给就能执行那就是空参数

2.映射配置文件写法：
1.是什么操作用什么标签（查询：select，更新：update，插入：insert，删除：delete）
2.id和接口方法名统一
3.参数是什么类型parameterType就是什么类型，是一个类就用全限定类名
4.返回值是什么类型resultType就是什么类型，是一个类就用全限定类名
5.写SQL语句。

3.主类怎么调用运行
1.创建Dao代理对象

 public void init()throws Exception{
        //1.读取配置文件生成字节输入流,使用getResourceAsStream时，抛出异常即可。
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        SqlSession sqlSession = factory.openSession();
        //openSession(true)参数true表示设置事务自动提交，默认为空参数，为手动提交
        //4.获取Dao的代理对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
    }

2.无参数的，普通参数类型的，将参数传入dao方法直接用代理对象调用，返回值什么类型就用什么类型装
3.参数是类，先创建对象。该给属性赋值的赋值，赋值后。将对象传入dao方法接着用代理对象调用，返回值什么类型就用什么类型装。
4.有返回值的输出，返回值为List<>的for循环遍历输出。
5.提交事务释放资源

 public void destory()throws Exception{
        //提交事务
        sqlSession.commit();
        //释放资源
        sqlSession.close();
        in.close();
 }
胡榕昆
关注
MyBatis 1章 入门(使用MyBatis完成CRUD)
03-24
**MyBatis入门教程——使用MyBatis完成CRUD操作** MyBatis是一个优秀的Java持久层框架，它简化了数据库操作，将SQL语句与Java代码分离，使得开发者能够更专注于业务逻辑。本教程将带你逐步了解如何使用MyBatis进行...
使用MyBatis实现CRUD
Mr. Xu的博客
11-03 788
MyBatis介绍： ​ mybatis 是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。 ​ mybatis 通过xml 或注解的方式将执行的各种statement 配置起来，并通过java 对象和statement 中sql的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql并将结果映射为 java 对象并返回。 采用 ORM (
使用Mybatis完成CRUD操作，并从源码分析执行过程
不思量
04-14 476
用案例演示如何使用Mybatis的两种方式（代理/实现DAO）进行CRUD操作，并且通过深入Mybatis源码，探究这两种方式具体的执行流程，最终推导出哪种方式更好。
使用mybatis框架完成数据库中的CRUD（使用工具类）
chenmixuexi_的博客
07-26 1298
mybatis框架的核心配置文件：创建一个名为resource的资源文件夹 ，用来存放配置文件 mybatis-config.xml的文件： <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <!--
Mybatis使用注解完成CRUD操作
csdnhyms的博客
03-15 243
Mybatis使用注解完成CRUD操作 使用注解比xml文件方便简单许多 这里完成最简单的CRUD操作 如果读者想使用的话，只需要修改数据库名就可以直接使用。 详细的解释大家可以看上一篇博文。 首先看实体类 package hym.bean; public class student { private int id; private String name; priva...
使用mybatis实现CRUD
04-07
标题 "使用mybatis实现CRUD" 涉及到的是在Java开发中使用MyBatis框架进行基本的数据操作，即创建（Create）、读取（Read）、更新（Update）和删除（Delete）。MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储...
【自虐1.2】Srping+MyBatis完成CRUD
08-05
【自虐1.2】Spring+MyBatis完成CRUD 在本文中，我们将深入探讨如何结合Spring框架和MyBatis轻量级持久层框架来实现数据库的基本操作，包括创建（Create）、读取（Read）、更新（Update）和删除（Delete），简称为...
05实现mybatis简单crud功能demo
最新发布
04-22
05实现mybatis简单crud功能demo05实现mybatis简单crud功能demo05实现mybatis简单crud功能demo05实现mybatis简单crud功能demo05实现mybatis简单crud功能demo05实现mybatis简单crud功能demo05实现mybatis简单crud功能...
MyBatisCRUD:MyBatis的CRUD操作
05-19
MyBatis CRUD操作Java，MyBatis，单元测试，MySql，Maven的CRUD操作这包含构建和运行MyBatisCRUD应用程序所需的一组指令。建设项目。先决条件设置了JDK 1.6.x或更高版本的Maven 2或更高版本的java_home和m2_home。...
Mybatis实现CRUD
qq_43677736的博客
11-15 428
Mybatis实现CRUD Mybatis简介 MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache soware foundation 迁移到了google code，并且改名为MyBatis 。2013 年11月迁移到Github。 iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久 层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO） MyBatis是一个支持普通S
用mybatis实现简单的CRUD
Alan_Xiang的博客
12-20 4587
下面介绍如何用mybatis实现简单的增删改查功能，有两种方式，一种是通过xml配置文件实现，一种是通过注解实现。 　　仍然通过对user的操作进行说明，新建好项目并导入jar包后，新建数据库和表，并插入两条记录：create database mybatis; use mybatis; CREATE TABLE users(id INT PRIMARY KEY AUTO_INCREMENT, N
使用mybatis完成简单的crud操作
m0_60336885的博客
04-20 723
目录 1.配置核心配置文件和jdbc.properties 2、 装mybatis工具类 3、创建实体类 4、创建mapper接口 5、编写测试类 下面介绍基于注解的方式实现基本的 CRUD 操作 1.配置核心配置文件和jdbc.properties 记扫描mapper包!!! <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org/
Mybatis 完成CRUD和动态sql使用
C.
05-06 1056
首先修改一下测试类，将相同的初始化代码提取出来： 插入User映射文件中加入： 测试方法和执行结果：根据id查询User，返回值为：Map映射文件中加入： 测试方法和执行结果： 添加User参数为HashMap映射文件中加入： 测试方法和执行结果： 根据id删除User映射文件中加入： 测试方法和执行结果： 根据id更新User映射文件中加入： 测试方法和执行结果： 根据id更新
MyBatis学习（二）--利用MyBatis实现CRUD操作
weixin_46705517的博客
03-10 192
文章目录一、查询表记录1.在映射器配置文件里引入结果映射元素2.添加按姓名查询用户记录功能（1）添加映射语句（2）在UserMapper接口里添加findByName()方法（3）TestUserMapper里添加测试方法testFindByName()二、插入表记录三、更新表记录四、删除表记录 一、查询表记录 1.在映射器配置文件里引入结果映射元素 在引入映射结果后，运行TestUserMapper会出现如下错误 我们将UserMapper文件中所绑定的SQL语句注释，然后再次运行程序，结果正确
查询java剩余的方法。
胡榕昆的博客
04-24 385
我们在开发过程中，经常会遇到内存溢出的情况，可以通过加日志的方式，来查看程序内存的占用情况。 private String getFreeMemory() { return Runtime.getRuntime().freeMemory() / 1024 / 1024 + "M"; }
在IDEA中，如何在一个文件夹下创建多个工程。
胡榕昆的博客
03-29 7538
IDEA不同于eclipse，在IDEA中project相当于eclipse的工作空间（workspace），而IDEA的module相当于eclipse中的project，但又不完全全相同。有时候我们希望在使用IDEA的时候，将创建的project放入一个指定的文件夹，方便管理。这时候会存在一些细节上的问题。 1.在我的电脑上创建了一个名为“workspace_idea”的空文件夹，我希望把创建...
Maven工程一定要使用标准的Maven目录结构，否则会有很多问题
AOBO516的专栏
05-22 1064
一般采用工具很容易创建出标准的maven目录结构，但是有时候创建的不正确或者想要做些定制，会导致工程结构不在符合标准目录结构，进而会出现许多问题。 如IntelliJ IDEA运行JMockit和Junit配合使用的用例执行报错；test目录的Junit用例无法执行，报不存在test用例等。 maven官网写的标准目录结构地址：http://maven.apache.org/guides/i...
SpringBoot整合Mybatis实现CRUD步骤详解
"SpringBoot整合Mybatis实现...通过以上步骤，即可完成Spring Boot与Mybatis的整合，实现对MySQL数据库的基本CRUD操作。在整个过程中，Spring Boot简化了配置，Mybatis提供了灵活的SQL操作，两者结合，使得开发更高效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值