实验1：用mybatis框架实现对数据库的操作-员工管理系统

最新推荐文章于 2024-03-21 09:59:24 发布

粄傑的诗

最新推荐文章于 2024-03-21 09:59:24 发布

阅读量884

点赞数 2

文章标签：数据库 mybatis oracle java-ee

本文链接：https://blog.csdn.net/m0_65783145/article/details/133386955

版权

2023年9月28日 17:01:18

要运行使用 MyBatis 框架实现的员工管理系统，需要进行以下步骤：

配置环境和依赖：首先，确保在项目中配置好 MyBatis 的环境和依赖。这包括设置 Maven 或 Gradle 的依赖项，以及引入 MyBatis 相关的 jar 文件。
创建数据库表：在数据库中创建与员工管理系统相关的表，包括员工表和其他关联表（如果有）。
编写实体类：创建与数据库表对应的实体类，使用注解或 XML 配置字段与数据库列的映射关系。
创建映射文件：编写 MyBatis 映射文件（XML 格式），定义与数据库交互的 SQL 语句。在映射文件中指定 SQL 语句的唯一标识，以及参数和结果类型的映射关系。
配置数据库连接信息：创建一个数据库连接配置文件，指定数据库驱动程序、数据库 URL、用户名和密码等连接信息。
创建 SqlSessionFactory：通过 MyBatis 的配置文件和数据库连接信息，创建一个 SqlSessionFactory 对象，该对象用于创建 SqlSession 实例。
执行数据库操作：在需要执行数据库操作的类中，通过 SqlSessionFactory 创建 SqlSession 对象，并使用该对象执行具体的数据库操作，如查询、插入、更新和删除等。
提交和关闭资源：在操作完毕后，记得提交事务（如果有）并关闭 SqlSession 对象，释放数据库资源。
运行程序：通过运行主类或测试类来启动员工管理系统，验证数据库操作的结果。

需要注意的是，具体的运行方式会因项目结构和开发环境而有所不同。通常，通过 IDE（如 IntelliJ IDEA 或 Eclipse）来运行项目，并确保项目的依赖、配置文件和目录结构正确配置。另外，根据具体情况，可能需要使用数据库连接池、事务管理等技术来提高系统的性能和可靠性。

好了，接下来就是正片了

我用的是IDEA的2023.2.2版本，可以在这个链接里找，破解工具啥的都有https://blog.idejihuo.com/jetbrains/intellij-idea-2022-3-3-permanent-activation-code-detailed-crack-tutorial.html

至于maven的版本如果idea的版本够高，兼容性应该没问题，如果是2020版本的话，根据 Maven 官方文档，IntelliJ IDEA 2020 版本兼容的 Maven 版本范围是 3.0.5 到 3.6.3。这意味着你可以在 IDEA 2020 中使用这个范围内的任何 Maven 版本，包括 3.0.5、3.1.x、3.2.x、3.3.x、3.4.x、3.5.x 和 3.6.x。然而，建议使用较新的 Maven 版本以获取更好的兼容性和稳定性。最新的 Maven 版本为 3.6.3，因此如果你使用 IDEA 2020，建议使用 Maven 3.6.3 来作为最高兼容版本，以确保最佳的运行效果

安装好之后呢开始创建项目，这是我自己创建的目录，因为在之前是有过测试的，所以关于UserMapper。xml和UserTest.java可以不用创建，

1创建数据库，这个创建的地方很多，SQLyog还有DataGrip，Navicat也是可以的，我自己用的是SQLyog,这个比较方便。按照表格来创建保存。

2引入相关的依赖在项目pom.XML文件中导入my SQL驱动包JUnit测试包和Mybatis的核心包等相关依赖

<?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.itheima</groupId>
    <artifactId>mybatistest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <!--   	        <scope>test</scope>-->
            <scope>compile</scope>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

</project>

3创建数据库连接配置文件这是db.properties文件的代码

mysql.driver=com.mysql.cj.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/employee?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
mysql.username=root
mysql.password=lzw

这个用户名和密码用自己Mysql的用户名密码，还有第二行的employee是自己表的名字不要写错

4创建Mybatis核心配置文件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>
    <!--环境配置-->
    <!--加载类路径下的属性文件-->
    <properties resource="db.properties"/>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!--数据库连接相关配置，db.properties文件中的内容-->
            <dataSource type="POOLED">
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="${mysql.username}"/>
                <property name="password" value="${mysql.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--mapping文件路径配置,用于将EmployeeMapper.xml映射文件加载到程序中-->
    <mappers>
        <mapper resource="mapper/EmployeeMapper.xml"/>
    </mappers>

</configuration>

这里要看自己的mapper合适着不。目录看清楚。到这开发环境就搭建好了

5. 创建pojo实体，创建com.itheima.pojo包，在这个包下面创建Employee类用于封装Employee对象的属性。

package com.itheima.pojo;

public class Employee {
    private Integer id;
    private String name;
    private Integer age;
    private String position;

    public void setId(Integer id)
    {
        this.id = id;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public void setAge(Integer age)
    {
        this.age = age;
    }
    public void setPosition(String position)
    {
        this.position = position;
    }

    public Integer getId()
    {
        return id;
    }
    public String getName()
    {
        return name;
    }
    public Integer getAge()
    {
        return age;
    }
    public String getPosition()
    {
        return position;
    }

    @Override
    public String toString() {
        return "Employee{"+"--------id="+id+",name="+name+",age="+age+",position="+position+"}";
    }
}
//    这段代码是一个简单的实体类 Employee，具体分析如下：
//
//        属性：
//
//        id：表示员工的唯一标识，类型为 Integer。
//        name：表示员工的姓名，类型为 String。
//        age：表示员工的年龄，类型为 Integer。
//        position：表示员工的职位，类型为 String。
//        Setter 和 Getter 方法：
//
//        setId(Integer id)、setName(String name)、setAge(Integer age)、setPosition(String position): 用于设置相应属性的值。
//        getId()、getName()、getAge()、getPosition(): 用于获取相应属性的值。
//        toString() 方法：
//        toString() 方法是 Java Object 类的方法，被重写以返回对象的字符串表示。在这段代码中，toString() 方法被重写为返回 Employee 对象的属性值拼接而成的字符串，格式为 "Employee{属性名1=属性值1, 属性名2=属性值2, ...}"。
//
//        这段代码干了个什么呢

//        该实体类的主要作用是用于封装员工对象的属性，提供了属性的设置和获取方法，并重写了 toString() 方法以方便输出对象的字符串表示。在使用 MyBatis 框架时，通常会将数据库表的字段和该实体类的属性进行映射，方便在操作数据库时进行对象和表之间的转换。
//这段代码定义了一个 Employee 类，是一个简单的实体类。它描述了一个员工对象，并提供了属性的封装方法和重写的 toString() 方法。
//
//        现在你可以使用这个实体类来创建和操作员工对象。例如，可以通过调用 setId()、setName()、setAge() 和setPosition() 方法来设置员工对象的属性值，通过调用 getId()、getName()、getAge() 和getPosition() 方法来获取员工对象的属性值。
//
//        此外，通过重写的 toString() 方法，可以方便地将员工对象转换为字符串表示，以便于输出或日志记录等操作。

6.创建映射文件EmployeeMapper.xml。用来配置SQL语句和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">

<mapper namespace="com.itheima.pojo.EmployeeMapper">

    <!--(1)根据id查询员工信息 -->
    <select id="select01" parameterType="Integer"
            resultType="com.itheima.pojo.Employee">
        select * from employee where id = #{id}
    </select>

    <!-- (2)新增员工信息 -->
    <insert id="insert02" parameterType="com.itheima.pojo.Employee">
        insert into employee(id,name,age,position)values (#{id},#{name},#{age},#{position})
    </insert>

    <!-- (3)根据id修改员工信息 -->
    <update id="update03" parameterType="com.itheima.pojo.Employee">
        update employee set name= #{name},age = #{age},position= #{position} where id = #{id}
    </update>

    <!-- (4)根据id删除员工信息 -->
    <delete id="delete04" parameterType="Integer">
        delete from employee where id=#{id}
    </delete>
</mapper>

<!--        这段代码是一个 MyBatis 的 Mapper XML 文件，用于映射数据库操作和 SQL 语句，实现对员工信息进行增删改查的功能。具体分析如下：-->

<!--        <?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">：指定 DTD 类型，用于验证 XML 的合法性。-->

<!--<mapper namespace="com.itheima.pojo.EmployeeMapper">：声明了命名空间，表示该XML文件对应的Mapper接口为 com.itheima.pojo.EmployeeMapper。-->

<!--<select>：定义了一个查询语句，根据员工id查询员工信息。-->

<!--    id：指定查询语句的id为 select01。-->
<!--    parameterType：指定传入参数的类型为 Integer。-->
<!--    resultType：指定查询结果的返回类型为 com.itheima.pojo.Employee。-->
<!--    SQL 语句：select * from employee where id = #{id}，使用 #{id} 表示参数占位符。-->
<!--    <insert>：定义了一个插入语句，用于新增员工信息。-->

<!--        id：指定插入语句的id为 insert02。-->
<!--        parameterType：指定传入参数的类型为 com.itheima.pojo.Employee。-->
<!--        SQL 语句：insert into employee(id,name,age,position) values (#{id},#{name},#{age},#{position})，使用 #{id}、#{name}、#{age}、#{position} 表示参数占位符。-->
<!--        <update>：定义了一个更新语句，用于根据员工id修改员工信息。-->

<!--            id：指定更新语句的id为 update03。-->
<!--            parameterType：指定传入参数的类型为 com.itheima.pojo.Employee。-->
<!--            SQL 语句：update employee set name=#{name},age=#{age},position=#{position} where id=#{id}，使用 #{id}、#{name}、#{age}、#{position} 表示参数占位符。-->
<!--            <delete>：定义了一个删除语句-->

7创建MyBatisUtils工具类用于封装读取配置文件信息的代码

package com.itheima.pojo;
import java.io.Reader;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisUtils {
    private static SqlSessionFactory sqlSessionFactory = null;
    //初始化SQLSessionFactory类加载MyBatis的配置文件
    static {
        try {
            //使用MyBatis提供的Resources类加载MyBatis的配置文件
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            //构建SqlSessionFactory工厂
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    public static SqlSession getSession(){
        //获取SqlSession对象的静态方法
        return sqlSessionFactory.openSession(true);
        //若传入true表示关闭事务控制，自动提交;false表示开启事务控制
    }
}
//    这段代码是一个工具类 MyBatisUtils，用于获取和管理 MyBatis 框架的 SqlSession 对象。具体分析如下：
//
//        import java.io.Reader;：导入 java.io.Reader 类，用于读取配置文件。
//        import org.apache.ibatis.io.Resources;：导入 MyBatis 的 Resources 类，用于加载配置文件。
//        import org.apache.ibatis.session.SqlSession;：导入 MyBatis 的 SqlSession 类，用于执行 SQL 语句和管理事务。
//        import org.apache.ibatis.session.SqlSessionFactory;：导入 MyBatis 的 SqlSessionFactory 类，用于创建 SqlSession 对象。
//        import org.apache.ibatis.session.SqlSessionFactoryBuilder;：导入 MyBatis 的 SqlSessionFactoryBuilder 类，用于构建 SqlSessionFactory 对象。
//        接下来是 MyBatisUtils 类的详细分析：
//
//private static SqlSessionFactory sqlSessionFactory = null;
//
//        定义一个静态的 SqlSessionFactory 对象 sqlSessionFactory，表示 MyBatis 的 SqlSessionFactory 实例。
//static {}：静态代码块，用于在类加载时初始化 sqlSessionFactory 对象。
//
//        在静态代码块中，通过 Resources.getResourceAsReader("mybatis-config.xml") 加载 MyBatis 的配置文件 mybatis-config.xml，并返回一个 Reader 对象。
//
//        使用 SqlSessionFactoryBuilder 的 build() 方法，通过传入配置文件的 Reader 对象，构建并初始化 sqlSessionFactory。
//
//public static SqlSession getSession()
//
//        定义一个公共的静态方法 getSession()，用于获取 SqlSession 对象。
//
//        在方法内部，通过调用 sqlSessionFactory 的 openSession() 方法，无参数地创建和返回一个新的 SqlSession 对象。
//
//        在 openSession() 方法中，传入 true 参数表示关闭事务控制，自动提交；传入 false 参数表示开启事务控制。
//
//        这段代码主要实现了获取和管理 MyBatis 框架的 SqlSession 对象的功能。通过读取配置文件 mybatis-config.xml，构建和初始化 SqlSessionFactory，
//        然后提供静态方法 getSession() 来获取 SqlSession 对象。在获取 SqlSession 时，可以选择开启或关闭事务控制。

8创建测试类，我把四个写在了一块

package Test;
import com.itheima.pojo.Employee;
import com.itheima.pojo.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class MyBatisTest {
    //(1)根据id查询员工信息
    @Test
    public void select01() {
        //通过工具类获取SQLSession对象
        SqlSession sqlSession = MyBatisUtils.getSession();
        //创建Employee对象接收SQL语句的查询结果
        Employee employee01 = sqlSession.selectOne("select01",2);
        System.out.println("查询成功");
        //关闭事务
        sqlSession.close();
    }
//    这段代码是 MyBatisTest 类中的 select01() 方法，用于根据员工的 ID 查询员工信息。具体分析如下：
//
//    @Test：这是 JUnit 框架提供的注解，用于标记该方法为测试方法。
//
//    SqlSession sqlSession = MyBatisUtils.getSession();：通过调用工具类 MyBatisUtils 的 getSession() 方法获取一个 SqlSession 对象，用于执行数据库操作。
//
//    Employee employee01 = sqlSession.selectOne("select01",2);：使用 SqlSession 对象的 selectOne() 方法执行查询操作。其中参数 "select01"
//    是映射文件中定义的要执行的 SQL 语句的唯一标识，参数 2 是传入的员工 ID。
//
//            System.out.println("查询成功");：输出提示信息。
//
//            sqlSession.close();：关闭 SqlSession，释放资源。
//
//    这段代码主要功能是使用 MyBatis 框架执行数据库查询操作。通过调用 SqlSession 的 selectOne() 方法，传入指定的 SQL 语句标识和参数，完成员工信息的查询操作。执行完毕后关闭 SqlSession。


    //(2)新增员工信息
    @Test
    public void insert02() {
        SqlSession sqlSession = MyBatisUtils.getSession();
        //实例化Employee
        Employee employee = new Employee();
        employee.setId(4);
        employee.setName("赵六");
        employee.setAge(100);
        employee.setPosition("老板");
        //这里的insertID一定要与EmployeeMapper文件中的id对应，要一模一样
        sqlSession.insert("insert02",employee);
        System.out.println("添加成功！");
        sqlSession.close();
    }
    //(3)根据id修改员工信息
    @Test
    public void update03() {
        SqlSession sqlSession = MyBatisUtils.getSession();
        Employee employee = new Employee();
        employee.setId(3);
        employee.setName("陈二");
        employee.setAge(40);
        employee.setPosition("经理");
        sqlSession.insert("update03",employee);
        System.out.println("更新成功！");
        sqlSession.close();
    }
    //(4)根据id删除员工信息
    @Test
    public void delete04() {
        SqlSession sqlSession = MyBatisUtils.getSession();
        sqlSession.delete("delete04", 1);
        System.out.println("删除成功！");
        sqlSession.close();
    }
}
//    这段代码是一个测试类 MyBatisTest，用于测试在数据库中执行一些操作。具体功能如下：
//
//        select01() 方法：根据员工的 ID 查询员工信息。
//        insert02() 方法：新增员工信息。
//        update03() 方法：根据员工的 ID 修改员工信息。
//        delete04() 方法：根据员工的 ID 删除员工信息。

9.在这里呢为了方便呢我又添加了一个菜单类，

package com.itheima.pojo;

import org.apache.ibatis.session.SqlSession;
import com.itheima.pojo.MyBatisUtils;

import java.util.Scanner;

public class idea {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("========= 员工菜单 =========");
            System.out.println("1. 查询员工信息");
            System.out.println("2. 新增员工信息");
            System.out.println("3. 修改员工信息");
            System.out.println("4. 删除员工信息");
            System.out.println("0. 退出");
            System.out.print("请选择操作：");

            int choice = scanner.nextInt();
            scanner.nextLine(); // 跳过空白行

            switch (choice) {
                case 1:
                    System.out.print("请输入查询员工ID：");
                    int id = scanner.nextInt();
                    scanner.nextLine();  // 跳过空白行
                    SqlSession sqlSession = MyBatisUtils.getSession();
                    //创建Employee对象接收SQL语句的查询结果
                    Employee employee01 = sqlSession.selectOne("select01", id);
                    System.out.println("查询成功："+employee01);
                    //关闭事务
                    sqlSession.close();
                    break;

                case 2:
                    System.out.print("请输入员工姓名：");
                    String name = scanner.nextLine();

                    System.out.print("请输入员工年龄：");
                    int age = scanner.nextInt();
                    scanner.nextLine();  // 跳过空白行

                    System.out.print("请输入员工职位：");
                    String position = scanner.nextLine();

                    Employee newEmployee = new Employee();
                    newEmployee.setName(name);
                    newEmployee.setAge(age);
                    newEmployee.setPosition(position);

                    SqlSession sqlSession1 = MyBatisUtils.getSession();
                    //实例化Employee

                    //这里的insertID一定要与EmployeeMapper文件中的id对应，要一模一样
                    sqlSession1.insert("insert02", newEmployee);
                    System.out.println("添加成功！");
                    sqlSession1.close();
                    break;

                case 3:
                    System.out.print("请输入要修改的员工ID：");
                    int updateId = scanner.nextInt();
                    scanner.nextLine();  // 跳过空白行

                    System.out.print("请输入员工姓名姓名：");
                    String updatedName = scanner.nextLine();


                    System.out.print("请输入员工年龄");
                    int updatedAge = scanner.nextInt();
                    scanner.nextLine();  // 跳过空白行


                    System.out.print("请输入员工职位");
                    String updatedPosition = scanner.nextLine();


                    SqlSession sqlSession2 = MyBatisUtils.getSession();
                    Employee employee = new Employee();
                    employee.setId(updateId);
                    employee.setName(updatedName);
                    employee.setAge(updatedAge);
                    employee.setPosition(updatedPosition);
                    sqlSession2.insert("update03", employee);
                    System.out.println("更新成功！");
                    sqlSession2.close();


                    break;

                case 4:
                    System.out.print("请输入要删除的员工ID：");
                    int deleteId = scanner.nextInt();
                    scanner.nextLine();  // 跳过空白行
                    SqlSession sqlSession3 = MyBatisUtils.getSession();
                    sqlSession3.delete("delete04", deleteId);
                    sqlSession3.close();
                    System.out.println("删除员工信息成功。");
                    break;

                case 0:
                    System.out.println("已退出员工菜单。");
                    System.exit(0);

                default:
                    System.out.println("无效的选择。请重新选择操作。");
                    break;
            }

            System.out.println("------------------------\n");
        }
    }
}

//    这段代码是一个主程序类 idea，用于实现对员工信息的增删改查操作。具体分析如下：
//
//        import org.apache.ibatis.session.SqlSession;：导入 MyBatis 的 SqlSession 类，用于执行 SQL 语句和管理事务。
//        import com.itheima.pojo.MyBatisUtils;：导入自定义的 MyBatisUtils 类，用于获取数据库连接的 SqlSession 对象。
//        import java.util.Scanner;：导入 Scanner 类，用于获取用户的输入。
//        在 main 方法中，使用一个 while 循环来处理员工菜单功能。循环主要包括以下部分：
//
//        使用 Scanner 获取用户的选择。
//        根据用户的选择，执行相应的操作：
//        查询员工信息（选项1）：获取用户输入的员工ID，并使用 SqlSession 执行 SQL 查询语句，返回结果并打印。
//        新增员工信息（选项2）：获取用户输入的员工姓名、年龄和职位，并根据输入创建一个新的 Employee 对象，将其插入数据库。
//        修改员工信息（选项3）：获取用户输入的员工ID、姓名、年龄和职位，并根据ID查询到要修改的员工对象，然后更新其属性值，并将更新后的对象存入数据库。
//        删除员工信息（选项4）：获取用户输入的员工ID，并执行删除操作，将对应的员工对象从数据库中删除。
//        退出程序（选项0）：结束循环，退出员工菜单。
//        默认情况（无效的选择）：提示用户重新选择操作。
//        此外，每次操作后，会输出一个分割线和一个换行，以增加菜单的可读性。
//
//        这段代码主要实现了一个简单的员工信息管理系统，使用了 MyBatis 框架来连接数据库并执行相应的数据库操作。根据用户的选择，调用对应的 SQL 语句进行增删改查操作。

10接下来进行测试

运行成功是这样的，或许有人问MyBatisTest用来干啥的，那个也是用来测试的，鼠标放在哪个函数上，就运行那个函数

下图是上面说的测试类的运行

mysql的配置大家可以找找相关的教程，可以看看我找的这个

MySQL安装配置教程（保姆级，包含环境变量的配置）适合小白_mysql安装与配置_君生我老的博客-CSDN博客

关于大家在项目过程中的问题，这是我找的一个连接教程，可以参考参考

https://blog.csdn.net/DDDBOOM/article/details/119133417?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522169589501416800213037314%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=169589501416800213037314&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v1~rank_v31_ecpm-2-119133417-null-null.142^v94^chatsearchT3_1&utm_term=%E5%91%98%E5%B7%A5%E7%AE%A1%E7%90%86%E7%B3%BB%E7%BB%9FjavaEE%E9%81%87%E5%88%B0%E7%9A%84%E9%97%AE%E9%A2%98%E8%A7%A3%E5%86%B3%E5%8A%9E%E6%B3%95&spm=1018.2226.3001.4187

到这的话，就结束了，希望我这篇文章对你们做项目有用，如果有不合适的地方可以指出，我再完善完善

粄傑的诗

关注

2
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
实验1：用mybatis框架实现对数据库的操作-员工管理系统

2023年9月28日 17:01:18要运行使用 MyBatis 框架实现的员工管理系统，需要进行以下步骤：配置环境和依赖：首先，确保在项目中配置好 MyBatis 的环境和依赖。这包括设置 Maven 或 Gradle 的依赖项，以及引入 MyBatis 相关的 jar 文件。创建数据库表：在数据库中创建与员工管理系统相关的表，包括员工表和其他关联表（如果有）。编写实体类：创建与数据库表对应的实体类，使用注解或 XML 配置字段与数据库列的映射关系。
复制链接

扫一扫