创建项目

new Project/new Module -> Maven->Create from archetype->maven-archetype-quickstart->包名,项目名->finish(默认)

修改目录

创建Resource root的resources目录(于java目录同级)

SM整合步骤

  • 建表
  • 新建项目，选择quickstart模板
  • 修改目录
  • 修改pom.xml文件，添加依赖关系
  • 添加Mybatis相应的模板(mybatis.xml和xxxMapper.xml文件)
  • 添加mybatis.xml文件(Mybatis核心配置文件),并创建配置jdbc.properties
  • 添加applicationContext_mapper.xml
  • 添加applicationContext_service.xml
  • 添加Users实体类和Account实体类
  • 添加mapper包,添加UsersMapper接口和UsersMapper.xml文件并开发
  • 添加service包,添加UsersService接口和UsersServiceImpl实现类
  • 添加测试类进行功能测试

修改pom.xml文件，添加依赖关系

  1. <?xml version="1.0" encoding="UTF-8"?>
  3. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.   <modelVersion>4.0.0</modelVersion>
  7.   <groupId>com.chentianyu</groupId>
  8.   <artifactId>sm_integration</artifactId>
  9.   <version>1.0-SNAPSHOT</version>
  11.   <properties>
  12.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  13.     <maven.compiler.source>1.8</maven.compiler.source>
  14.     <maven.compiler.target>1.8</maven.compiler.target>
  15.   </properties>
  17.   <dependencies>
  18.     <dependency>
  19.       <!--单元测试-->
  20.       <groupId>junit</groupId>
  21.       <artifactId>junit</artifactId>
  22.       <version>4.11</version><!--ssm整合这里测试类，必须4.12-->
  23.       <scope>test</scope>
  24.     </dependency>
  25.     <!--aspectj依赖-->
  26.     <dependency>
  27.       <groupId>org.springframework</groupId>
  28.       <artifactId>spring-aspects</artifactId>
  29.       <version>5.3.17</version>
  30.     </dependency>
  31.     <!--spring核心ioc-->
  32.     <dependency>
  33.       <groupId>org.springframework</groupId>
  34.       <artifactId>spring-context</artifactId>
  35.       <version>5.3.16</version>
  36.     </dependency>
  37.     <!--做spring事务用到的-->
  38.     <dependency>
  39.       <groupId>org.springframework</groupId>
  40.       <artifactId>spring-tx</artifactId>
  41.       <version>5.3.16</version>
  42.     </dependency>
  43.     <dependency>
  44.       <groupId>org.springframework</groupId>
  45.       <artifactId>spring-jdbc</artifactId>
  46.       <version>5.3.16</version>
  47.     </dependency>
  48.     <!--mybatis依赖-->
  49.     <dependency>
  50.       <groupId>org.mybatis</groupId>
  51.       <artifactId>mybatis</artifactId>
  52.       <version>3.5.9</version>
  53.     </dependency>
  54.     <!--mybatis和spring集成的依赖-->
  55.     <dependency>
  56.       <groupId>org.mybatis</groupId>
  57.       <artifactId>mybatis-spring</artifactId>
  58.       <version>2.0.7</version>
  59.     </dependency>
  60.     <!--mysql驱动-->
  61.     <dependency>
  62.       <groupId>mysql</groupId>
  63.       <artifactId>mysql-connector-java</artifactId>
  64.       <version>8.0.28</version>
  65.     </dependency>
  66.     <!--阿里公司的数据库连接池-->
  67.     <dependency>
  68.       <groupId>com.alibaba</groupId>
  69.       <artifactId>druid</artifactId>
  70.       <version>1.2.8</version>
  71.     </dependency>
  72.   </dependencies>
  74.   <build>
  75.     <!--目的是把src/main/java目录中的xml文件包含到输出结果中。输出到classes目录中-->
  76.     <resources>
  77.       <resource>
  78.         <directory>src/main/java</directory><!--所在的目录-->
  79.         <includes><!--包括目录下的.properties,.xml文件都会扫描到-->
  80.           <include>**/*.xml</include>
  81.           <include>**/*.properties</include>
  82.         </includes>
  83.       </resource>
  85.       <resource>
  86.         <directory>src/main/resources</directory>
  87.         <includes>
  88.           <include>**/*.xml</include>
  89.           <include>**/*.properties</include>
  90.         </includes>
  91.       </resource>
  92.     </resources>
  93.   </build>
  94. </project>

添加数据库的可视化

为了更方便的进行数据库的操作，得创建数据库的可视化

右边Maven旁的Database->+->Data Source->mysql->user、password、Database

添加Mybatis相应的模板

添加模板

file->Settings->找到Editor->File and Code Templates -> Files -> +(将要创建模板的名称,我们将mybatis改为SqlMapperConfig(name)和xml格式(Extension)) ->

<?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"></properties>
        <!--设置日志输出语句，显示相应的操作的sql语名-->
        <settings>
            <setting name="logImpl" value="STDOUT_LOGGING" />
        </settings>
        <typeAliases>
            <package name="com.chentianyu.pojo"></package>
        </typeAliases>
        <environments default="dev">
            <environment id="dev">
                <transactionManager type="JDBC" />
                <dataSource type="POOLED">
                    <property name="driver" value="${jdbc.driverClassName}" />
                    <property name="url" value="${jdbc.url}" />
                    <property name="username" value="${jdbc.username}" />
                    <property name="password" value="${jdbc.password}" />
                </dataSource>
            </environment>
        </environments>
        <mappers>
            <package name="mapper文件所在的包名"></package>
        </mappers>
    </configuration>

新建XXXMapper.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">
<mapper namespace="接口的完全限定名称">

</mapper>

Apply(应用)->OK就可以了

resources->new-> SqlMapperConfig->你的核心配置文件名称，我们就取名为mybatis

但是我们的核心配置文件可以为空，因为spring接管了mybatis功能，整合mybatis框架

<?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>

</configuration>

但是有些内容是spring接管不了的,就写在mybatis的核心配置文件中(比如分页插件,缓存的处理等)

创建配置jdbc.properties
jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.username=root
jdbc.password=你的数据库密码

添加applicationContext_mapper.xml

new -> XML Configuration File-> Spring Config -> applicationContext_mapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--读取属性文件jdbc.properties-->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>
    <!--创建数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--配置SqlSessionFactoryBean类-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--配置数据源-->
        <property name="dataSource" ref="dataSource"></property>
        <!--配置mybatis的核心配置文件-->
        <property name="configLocation" value="mybatis.xml"></property>
        <!--注册实体类的别名-->
        <property name="typeAliasesPackage" value="com.chentianyu.pojo"></property>
    </bean>
    <!--注册mapper.xml-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.chentianyu.mapper"></property>
    </bean>
</beans>

这样spring接管mybatis功能完毕,但是既然你在这个配置文件里面配置了，那么mybatis的核心配置文件就得先清空,不然会报错

添加applicationContext_service.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--SM是基于注解的开发，所以添加包扫描-->
    <context:component-scan base-package="com.chentianyu.service.impl" />
    <!--事务处理,先不写-->
</beans>

添加Users实体类和Account实体类

package com.chentianyu.pojo;

/**
 *
 */
public class Users {
    private Integer userid;
    private String uname;
    private String upass;

    public Users() {
    }

    public Users(Integer userid, String uname, String upass) {
        this.userid = userid;
        this.uname = uname;
        this.upass = upass;
    }

    public Users(String uname, String upass) {
        this.uname = uname;
        this.upass = upass;
    }

    public Integer getUserid() {
        return userid;
    }

    public void setUserid(Integer userid) {
        this.userid = userid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public String getUpass() {
        return upass;
    }

    public void setUpass(String upass) {
        this.upass = upass;
    }

    @Override
    public String toString() {
        return "Users{" +
                "userid=" + userid +
                ", uname='" + uname + '\'' +
                ", upass='" + upass + '\'' +
                '}';
    }
}

package com.chentianyu.pojo;

public class Account {
    private Integer aid;
    private String aname;
    private String acontent;

    public Account() {
    }

    public Account(Integer aid, String aname, String acontent) {
        this.aid = aid;
        this.aname = aname;
        this.acontent = acontent;
    }

    public Account(String aname, String acontent) {
        this.aname = aname;
        this.acontent = acontent;
    }

    public Integer getAid() {
        return aid;
    }

    public void setAid(Integer aid) {
        this.aid = aid;
    }

    public String getAname() {
        return aname;
    }

    public void setAname(String aname) {
        this.aname = aname;
    }

    public String getAcontent() {
        return acontent;
    }

    public void setAcontent(String acontent) {
        this.acontent = acontent;
    }

    @Override
    public String toString() {
        return "Account{" +
                "aid=" + aid +
                ", aname='" + aname + '\'' +
                ", acontent='" + acontent + '\'' +
                '}';
    }
}

总结就是创建与mysql中字段名一致的属性与无参构造方法、全参构造方法、除主键外的全参构造方法,Getter和Setter方法(全部)和重写toString()方法

添加mapper包,添加UsersMapper接口和UsersMapper.xml文件并开发

package com.chentianyu.mapper;

import com.chentianyu.pojo.Users;

/**
 * 
 */
public interface UsersMapper {
    //增加数据
    int insertUsers(Users users);
}

使用XXXMapper的模板，创建UsersMapper.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">
<mapper namespace="com.chentianyu.mapper.UsersMapper">
    <!--
    //添加用户
    int insertUsers(Users users);
    实体类:
    private Integer userid;
    private String uname;
    private String upass;
    -->
    <insert id="insertUsers" parameterType="users">
        insert into users values(#{userid},#{uname},#{upass})
    </insert>
</mapper>

添加service包,添加UsersService接口和UsersServiceImpl实现类

package com.chentianyu.service;

import com.chentianyu.pojo.Users;

/**
 * UsersService接口
 */
public interface UsersService {
    //增加用户
    int insertUsers(Users users);
}

package com.chentianyu.service.impl;

import com.chentianyu.mapper.UsersMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * UsersService的实现类
 */
@Service    //交给spring去创建对象
public class UsersServiceImpl {
    //切记切记:在所有的业务逻辑层中一定会有数据访问层的对象
    /**
     * 过去写的
     *  //1.读取核心配置文件
     *  InputStream in = Resources.getResourceAsStream("mybatis.xml");
     *  //2.创建SqlSessionFactory对象
     *  SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
     *  //3.取出SqlSession
     *  SqlSession sqlSession = factory.openSession();
     *  //4.取出动态代理的对象，完成接口中的方法的调用，实则是调用xml文件中的标签功能
     *  uMapper = sqlSession.getMapper(UsersMapper.class);
     */
    //你在多层架构的整合中，你想用底层的对象，一个注解(@Autowired)搞定
    @Autowired
    UsersMapper usersMapper;//spring的@Autowired自动注入就给你干了以上的活

}

你在多层架构的整合中，你想用底层的对象，一个注解(@Autowired)搞定

实现UsersService中的功能

package com.chentianyu.service.impl;

import com.chentianyu.mapper.UsersMapper;
import com.chentianyu.pojo.Users;
import com.chentianyu.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * UsersService的实现类
 */
@Service    //交给spring去创建对象
public class UsersServiceImpl implements UsersService {//添加实现
    //切记切记:在所有的业务逻辑层中一定会有数据访问层的对象
    /**
     * 过去写的
     *  //1.读取核心配置文件
     *  InputStream in = Resources.getResourceAsStream("mybatis.xml");
     *  //2.创建SqlSessionFactory对象
     *  SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
     *  //3.取出SqlSession
     *  SqlSession sqlSession = factory.openSession();
     *  //4.取出动态代理的对象，完成接口中的方法的调用，实则是调用xml文件中的标签功能
     *  uMapper = sqlSession.getMapper(UsersMapper.class);
     */
    //你在多层架构的整合中，你想用底层的对象，一个注解(@Autowired)搞定
    @Autowired
    UsersMapper usersMapper;//spring的@Autowired自动注入就给你干了以上的活

    @Override
    public int insertUsers(Users users) {//实现UsersService接口中的方法
        return usersMapper.insertUsers(users);//底层的直接调用
    }
}

业务逻辑层开发完毕

做重要的一点就是@Autowired UsersMapper usersMapper;要小心,在这之前要在类上添加@Service(就是跟@Component一样的功能:把方法对象注册到ioc容器中),在哪之前要添加包扫描<context:component-scan base-package="包下的全部类都会扫描，所以写是包的全限定名称" />

目前为止的测试

因为ClassPathXmlApplicationContext只能添加一个所以只能把applicationContext_mapper.xml注册进applicationContext_service.xml中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--直接导入applicationContext_mapper.xml-->
    <import resource="applicationContext_mapper.xml"/>
    <!--SM是基于注解的开发，所以添加包扫描-->
    <context:component-scan base-package="com.chentianyu.service.impl" />
    <!--事务处理,先不写-->
</beans>

package com.chentianyu.test;

import com.chentianyu.pojo.Users;
import com.chentianyu.service.UsersService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppTest {
    @Test
    public void testUsers(){
        //创建容器并启动
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext_service.xml");
        //取出UsersServiceImpl(永远是接口接(干活))
        UsersService uService = (UsersService) ac.getBean("usersServiceImpl");
        int num = uService.insertUsers(new Users(1,"张三","123"));
        System.out.println(num);
    }
}

4月 16, 2022 6:56:03 下午 com.alibaba.druid.support.logging.JakartaCommonsLoggingImpl info
信息: {dataSource-1} inited
1

红色是日志的颜色不是错误

用可视化工具看看user表

userid uname upass
1 张三 123

没有用commit()所以是自动提交；不能回滚，要用事务来控制

同样的方法创建Account

package com.chentianyu.mapper;

import com.chentianyu.pojo.Account;

public interface AccountMapper {
    //添加账户
    int insertAccount(Account account);
}

<?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.chentianyu.mapper.AccountMapper">
    <!--
    //添加账户
    int insertAccount(Account account);
    实体类:
    private Integer aid;
    private String aname;
    private String acontent;
    -->
    <insert id="insertAccount" parameterType="account">
        insert into account values(#{aid},#{aname},#{acontent})
    </insert>
</mapper>

package com.chentianyu.service;

import com.chentianyu.pojo.Account;

public interface AccountService {
    int insertAccount(Account account);
}

package com.chentianyu.service.impl;

import com.chentianyu.mapper.AccountMapper;
import com.chentianyu.pojo.Account;
import com.chentianyu.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service//业务逻辑层
public class AccountServiceImpl implements AccountService {
    //但凡是业务逻辑层的实现类，一定会有数据访问层的对象
    @Autowired
    AccountMapper accountMapper;

    @Override
    public int insertAccount(Account account) {
        return accountMapper.insertAccount(account);
    }
}

测试

@Test
public void testUsers(){
    //创建容器并启动
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext_service.xml");
    //取出UsersServiceImpl(永远是接口接(干活))
    AccountService aService = (AccountService) ac.getBean("accountServiceImpl");
    aService.insertUsers(new Account(1,"李四","账户安全"));
}