学习SSM的记录（七）-- SSM整合

public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

  //指定root容器对应的配置类
  //root容器的配置类
  @Override
  protected Class<?>[] getRootConfigClasses() {
    return new Class<?>[] { ServiceJavaConfig.class,MapperJavaConfig.class };
  }
  
  //指定web容器对应的配置类 webioc容器的配置类
  @Override
  protected Class<?>[] getServletConfigClasses() {
    return new Class<?>[] { WebJavaConfig.class };
  }
  
  //指定dispatcherServlet处理路径，通常为 / 
  @Override
  protected String[] getServletMappings() {
    return new String[] { "/" };
  }
}

SSM整合配置实战

1.数据库准备

CREATE DATABASE mybatis-example;

USE mybatis_example;

CREATE TABLE t_emp(
  emp_id INT AUTO_INCREMENT,
  emp_name CHAR(100),
  emp_salary DOUBLE(10,5),
  PRIMARY KEY(emp_id)
);

INSERT INTO t_emp(emp_name,emp_salary) VALUES("tom",200.33);
INSERT INTO t_emp(emp_name,emp_salary) VALUES("jerry",666.66);
INSERT INTO t_emp(emp_name,emp_salary) VALUES("andy",777.77);

2.创建项目

web项目名：ssm-integration

3.导入依赖

spring相关依赖：
- ioc/di：spring-context 6.0.6
- jakarta.annotation-api 2.1.1 （通过了@Resource注解，jsr250系列）
aop：~~spring-aop 6.0.6~~（被spring-context传递）
- spring-aspects 6.0.6（会传递aspectj，spring使用的aop注解由它提供）
tx：spring-tx 6.0.6（有事务管理器的接口和增强）
- spring-jdbc 6.0.6（有事务管理器的实现）
springmvc相关依赖：
- spring-webmvc 6.0.6
- jakarta.jakartaee-web-api 9.1.0 （servlet）
- jackson-databind 2.15.0（json处理）
- hibernate-validator / hibernate-validator-annotation-processor 8.0.0（校验注解需要的实现）
mybatis相关依赖：
- mybatis 3.5.11
- mysql 8.0.25
- pagehelper 5.1.11
SSM整合相关依赖：
- 加载spring容器：spring-web 6.0.6
- 整合mybatis：mybatis-spring
- 数据库连接池：druid
- lombok：lombok 1.18.26
- logback：logback 1.2.3

<?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.atguigu</groupId>  
  <artifactId>part04-ssm-integration</artifactId>  
  <version>1.0-SNAPSHOT</version>  
  <packaging>war</packaging>
  <properties>
    <spring.version>6.0.6</spring.version>
    <jakarta.annotation-api.version>2.1.1</jakarta.annotation-api.version>
    <jakarta.jakartaee-web-api.version>9.1.0</jakarta.jakartaee-web-api.version>
    <jackson-databind.version>2.15.0</jackson-databind.version>
    <hibernate-validator.version>8.0.0.Final</hibernate-validator.version>
    <mybatis.version>3.5.11</mybatis.version>
    <mysql.version>8.0.25</mysql.version>
    <pagehelper.version>5.1.11</pagehelper.version>
    <druid.version>1.2.8</druid.version>
    <mybatis-spring.version>3.0.2</mybatis-spring.version>
    <jakarta.servlet.jsp.jstl-api.version>3.0.0</jakarta.servlet.jsp.jstl-api.version>
    <logback.version>1.2.3</logback.version>
    <lombok.version>1.18.26</lombok.version>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>  
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 
  </properties>
  <!--
     需要依赖清单分析:
        spring
          ioc/di
            spring-context / 6.0.6
            jakarta.annotation-api / 2.1.1  jsr250
          aop
            spring-aspects / 6.0.6
          tx
            spring-tx  / 6.0.6
            spring-jdbc / 6.0.6

        springmvc
           spring-webmvc 6.0.6
           jakarta.jakartaee-web-api 9.1.0
           jackson-databind 2.15.0
           hibernate-validator / hibernate-validator-annotation-processor 8.0.0.Final
         
        mybatis
           mybatis  / 3.5.11
           mysql    / 8.0.25
           pagehelper / 5.1.11

        整合需要
           加载spring容器 spring-web / 6.0.6
           整合mybatis   mybatis-spring x x
           数据库连接池    druid / x
           lombok        lombok / 1.18.26
           logback       logback/ 1.2.3
  -->

  <dependencies>
    <!--spring pom.xml依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>jakarta.annotation</groupId>
      <artifactId>jakarta.annotation-api</artifactId>
      <version>${jakarta.annotation-api.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>


    <!--
       springmvc
           spring-webmvc 6.0.6
           jakarta.jakartaee-web-api 9.1.0
           jackson-databind 2.15.0
           hibernate-validator / hibernate-validator-annotation-processor 8.0.0.Final
    -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>jakarta.platform</groupId>
      <artifactId>jakarta.jakartaee-web-api</artifactId>
      <version>${jakarta.jakartaee-web-api.version}</version>
      <scope>provided</scope>
    </dependency>

    <!-- jsp需要依赖! jstl-->
    <dependency>
      <groupId>jakarta.servlet.jsp.jstl</groupId>
      <artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
      <version>${jakarta.servlet.jsp.jstl-api.version}</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson-databind.version}</version>
    </dependency>


    <!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator -->
    <dependency>
      <groupId>org.hibernate.validator</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>${hibernate-validator.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator-annotation-processor -->
    <dependency>
      <groupId>org.hibernate.validator</groupId>
      <artifactId>hibernate-validator-annotation-processor</artifactId>
      <version>${hibernate-validator.version}</version>
    </dependency>


    <!--
      mybatis
           mybatis  / 3.5.11
           mysql    / 8.0.25
           pagehelper / 5.1.11
    -->
    <!-- mybatis依赖 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>

    <!-- MySQL驱动 mybatis底层依赖jdbc驱动实现,本次不需要导入连接池,mybatis自带! -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>

    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>${pagehelper.version}</version>
    </dependency>

    <!-- 整合第三方特殊依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis-spring.version}</version>
    </dependency>

    <!-- 日志 ， 会自动传递slf4j门面-->
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>${logback.version}</version>
    </dependency>

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>${lombok.version}</version>
    </dependency>
    
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>${druid.version}</version>
    </dependency>
    
  </dependencies>

</project>

4.创建实体类

@Data
public class Employee {

    private Integer empId;
    private String empName;
    private Double empSalary;
}

5.编写logback配置文件

路径：resources/logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <!-- 指定日志输出的位置，ConsoleAppender表示输出到控制台 -->
    <appender name="STDOUT"
              class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 日志输出的格式 -->
            <!-- 按照顺序分别是：时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 -->
            <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- 设置全局日志级别。日志级别按顺序分别是：TRACE、DEBUG、INFO、WARN、ERROR -->
    <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
    <root level="DEBUG">
        <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
        <appender-ref ref="STDOUT" />
    </root>

    <!-- 根据特殊需求指定局部日志级别，可也是包名或全类名。 -->
    <logger name="com.qiu.mybatis" level="DEBUG" />

</configuration>

6.控制层配置编写（SpringMVC 整合）

创建配置类：com.qiu.config.WebMvcJavaConfig.java

该类是专门配置控制层的，controller，springmvc

1.controller 2.全局异常处理器 3.handlerAdapter 4.handlerMapping

5.静态资源处理 6.jsp 视图解析器前后缀 7.json转化器 8拦截器 ……

@Configuration
@ComponentScan({"com.qiu.controller","com.qiu.exceptionhandler"})
@EnableWebMvc
public class WebMvcJavaConfig implements WebMvcConfigurer {
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.jsp("/WEB-INF/views",".jsp");
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
//        registry.addInterceptor(new 拦截器()).addPathPatterns().excludePathPatterns();
    }
}

7. 业务层配置编写（AOP / TX整合）

主要配置service，aop 和 tx 相关配置

创建配置类：com.qiu.config.ServiceJavaConfig.java

该类是专门配置业务层的，service，aop，tx

1.service 2.开启aop注解的支持（aspect的注解：@Before，@After……）

3.tx声明式事务管理（对应的管理器实现【TransactionManager接口，它的实现类：DataSourceTransactionManager，Hibernate…，Jpa……】，开启事务注解支持@Transactional）

@Configuration
@EnableAspectJAutoProxy
@EnableTransactionManagement()
@ComponentScan({"com.qiu.service"})
public class ServiceJavaConfig {
    public TransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);//需要一个连接池
        return transactionManager;
    }
}

8. 持久层配置编写（MyBatis 整合）

主要配置mapper代理对象，连接池和MyBatis核心组件配置

mybatis核心操作回顾：

//1.读取外部配置文件
InputStream ips = Resources.getResourceAsStream("mybatis-config.xml");

//2.创建sqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(ips);

//3.创建sqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
//4.获取mapper代理对象
EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
//5.数据库方法调用
int rows = empMapper.deleteEmpById(1);
System.out.println("rows = " + rows);
//6.提交和回滚
sqlSession.commit();
sqlSession.close();

mybatis核心api：

SqlSessionFactoryBuilder：当创建了SqlSessionFactory后，该api就不需要了，因此不需要ioc容器管理。

SqlSessionFactory：一旦创建，就不应该被丢弃，需要ioc容器管理。

SqlSession：每个线程都应该有对应的SqlSession实例，SqlSession实例不能被共享，不需要ioc容器管理。

Mapper映射器实例：Mapper实例一般和SqlSession相同不需要ioc容器，但service总是需要mapper接口注入，因此mapper实例应该被ioc容器管理。

mybatis整合的思路：把SqlSessionFactory进入ioc容器

方法1：自己实现，但太过繁琐

@Bean
public SqlSessionFactory sqlSessionFactory(){
   //1.读取外部配置文件
  InputStream ips = Resources.getResourceAsStream("mybatis-config.xml");
  
  //2.创建sqlSessionFactory
  SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(ips);
  
  return sqlSessionFactory;
}

方法2：mybatis提供了提供封装SqlSessionFactory和Mapper实例化的逻辑的FactoryBean组件，我们只需要声明和配置即可。

SqlSessionFactoryBean源码（Mybatis提供）：

package org.mybatis.spring;

public class SqlSessionFactoryBean
    implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ContextRefreshedEvent> {
    
       //封装了实例化流程
       public SqlSessionFactory getObject() throws Exception {
          if (this.sqlSessionFactory == null) {
            //实例化对象逻辑
            afterPropertiesSet();
          }
          //返回对象逻辑
          return this.sqlSessionFactory;
       }
   
}

mybatis整合思路总结：将SqlSessionFactory和Mapper实例加入到IoC容器

使用mybatis整合包提供的FactoryBean快速整合

操作步骤：

1、准备数据库连接配置文件：resources/jdbc.properties

jdbc.username=root
jdbc.password=123456
jdbc.url=jdbc:mysql:///mybatis_example
jdbc.driver=com.mysql.cj.jdbc.Driver

2、整合操作

整合方式1：保留mybatis-config.xml，但数据库连接信息，连接池信息使用Druid连接池，mapper接口的包指定使用java类指定，所以不需要在此文件下编写。

<?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>
    <settings>
        <!-- 开启驼峰式映射-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- 开启logback日志输出-->
        <setting name="logImpl" value="SLF4J"/>
        <!--开启resultMap自动映射 -->
        <setting name="autoMappingBehavior" value="FULL"/>
    </settings>

    <typeAliases>
        <!-- 给实体类起别名 -->
        <package name="com.qiu.pojo"/>
    </typeAliases>

    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!--
                helperDialect：分页插件会自动检测当前的数据库链接，自动选择合适的分页方式。
                你可以配置helperDialect属性来指定分页插件使用哪种方言。配置时，可以使用下面的缩写值：
                oracle,mysql,mariadb,sqlite,hsqldb,postgresql,db2,sqlserver,informix,h2,sqlserver2012,derby
                （完整内容看 PageAutoDialect） 特别注意：使用 SqlServer2012 数据库时，
                https://github.com/pagehelper/Mybatis-PageHelper/blob/master/wikis/zh/HowToUse.md#%E5%A6%82%E4%BD%95%E9%85%8D%E7%BD%AE%E6%95%B0%E6%8D%AE%E5%BA%93%E6%96%B9%E8%A8%80
             -->
            <property name="helperDialect" value="mysql"/>
        </plugin>
    </plugins>
</configuration>

创建配置类：MapperJavaConfig.java

该类是专门配置持久层的，连接池，sqlSessionFactory,Mapper代理对象

@Configuration
@PropertySource("classpath:jdbc.properties")
public class MapperJavaConfig  {
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.driver}")
    private String driver;

    @Bean
    public DataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        druidDataSource.setUrl(url);
        druidDataSource.setDriverClassName(driver);
        return druidDataSource;
    }
    //SqlSessionFactory进入ioc容器
    //使用mybatis提供的SqlSessionFactoryBean中的getObject()会完成SqlSessionFactory实例化
    //我们只需要把该实例加到ioc容器中
//    方式1：使用mybatis-config.xml
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();

        //指定数据库连接池对象
        sqlSessionFactoryBean.setDataSource(dataSource);
        //指定mybatis配置文件
        Resource resource=new ClassPathResource("mybatis-config.xml");
        sqlSessionFactoryBean.setConfigLocation(resource);
        return sqlSessionFactoryBean;
    }
    //把mapper代理对象加入到ioc
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        //mapper代理对象的FactoryBean 把指定的包下的mapper接口使用SqlSessionFactory获取SqlSession来生成全部mapper代理对象加到ioc容器
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.qiu.mapper");//mapper接口和mapper.xml所在的共同包
        return mapperScannerConfigurer;
    }
}

该代码存在bug（@Value不生效），因为DataSource与mybatis组件在同一个配置类中，mybatis组件先于DataSource加载，@Value还未读取。

解决方法：创建com.qiu.config.DataSourceJavaConfig.java配置类来配置DataSource

@Configuration
@PropertySource("classpath:jdbc.properties")
public class DataSourceJavaConfig {
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.driver}")
    private String driver;

    @Bean
    public DataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        druidDataSource.setUrl(url);
        druidDataSource.setDriverClassName(driver);
        return druidDataSource;
    }
}

整合方式2：完全配置类，去掉mybatis-config.xml，使用SqlSessionFactoryBean代替，所有配置信息（settings，插件，别名等）在SqlSessionFactoryBean的代码中指定，数据库依然使用DruidDataSource。

@Configuration
public class MapperJavaConfig  {

    //SqlSessionFactory进入ioc容器
    //使用mybatis提供的SqlSessionFactoryBean中的getObject()会完成SqlSessionFactory实例化
    //我们只需要把该实例加到ioc容器中
//    方式2：不使用mybatis-config.xml
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        //指定数据库连接池对象
        sqlSessionFactoryBean.setDataSource(dataSource);
        //使用代码指定mybatis配置文件的功能
        //settings设置
//        org.apache.ibatis.session.Configuration类型为存储settings的配置文件
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
//        开启驼峰映射
        configuration.setMapUnderscoreToCamelCase(true);
//        日志输出
        configuration.setLogImpl(Slf4jImpl.class);
//        开启resultMap多层自动映射
        configuration.setAutoMappingBehavior(AutoMappingBehavior.FULL);
        sqlSessionFactoryBean.setConfiguration(configuration);
        //别名设置
        sqlSessionFactoryBean.setTypeAliasesPackage("com.qiu.pojo");
        //插件设置
//        分页插件
        PageInterceptor pageInterceptor = new PageInterceptor();
        Properties properties=new Properties();
        properties.setProperty("helperDialect","mysql");
        pageInterceptor.setProperties(properties);
        sqlSessionFactoryBean.addPlugins(pageInterceptor);

        return sqlSessionFactoryBean;
    }
    //把mapper代理对象加入到ioc
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        //mapper代理对象的FactoryBean 把指定的包下的mapper接口使用SqlSessionFactory获取SqlSession来生成全部mapper代理对象加到ioc容器
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.qiu.mapper");//mapper接口和mapper.xml所在的共同包
        return mapperScannerConfigurer;
    }
}

9.容器初始化配置类

创建一个配置类，让它继承AbstractAnnotationConfigDispatcherServletInitializer

public class SpringIoCInit extends AbstractAnnotationConfigDispatcherServletInitializer {
    //rootioc容器的配置类
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{MapperJavaConfig.class, DataSourceJavaConfig.class, ServiceJavaConfig.class};
    }

    //webioc容器的配置类
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebMvcJavaConfig.class};
    }

    //dispatcherServlet的拦截路径
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

10.整合测试

查询所有员工信息，并返回对应JSON信息

创建com.qiu.mapper.EmployeeMapper.java（这里不需要@Repository，已经在MapperJavaConfig下配置了所有Mapper实例）

public interface EmployeeMapper {
    List<Employee> queryList();
}

在resources下创建com.qiu.mapper.EmployeeMapper.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.qiu.mapper.EmployeeMapper">
    <select id="queryList" resultType="employee">
        select *
        from t_emp;
    </select>
</mapper>

创建com.qiu.service.EmployeeService.java

public interface EmployeeService {
    List<Employee> findAll();
}

创建com.qiu.service.impl.EmployeeServiceImpl.java（这里employeeMapper可能有红色波浪线，但不影响运行）

@Service
public class EmployeeServiceImpl implements EmployeeService {

    @Autowired
    private EmployeeMapper employeeMapper;
    @Override
    public List<Employee> findAll() {
        List<Employee> employees = employeeMapper.queryList();
        return employees;
    }
}

创建com.qiu.controller.EmployeeController.java

@Controller
@ResponseBody
@RequestMapping("emp")
public class EmployeeController {

    @Autowired
    private EmployeeService employeeService;

    @GetMapping("find")
    public List<Employee> findAll(){
        List<Employee> all = employeeService.findAll();
        return all;
    }
}

配置tomcat并启动

访问 localhost:8080/emp/find

千字符

关注

28
点赞
踩
23

收藏

觉得还不错? 一键收藏
1
评论
学习SSM的记录（七）-- SSM整合

微观：在项目中使用Spring，SpringMVC，MyBatis宏观：Spring管理一切（将框架核心组件交给Spring进行ioc管理）实施：通过编写配置文件，实现SpringIoC容器接管一切组件。
复制链接

扫一扫