使用IDEA搭建SSM项目

  摘要：前几天学习了SSM项目的搭建，但是因为配置过程中出现了问题因此没有搭起来，我最讨厌不确定的事情，因此自己花费了点时间钻研搭建SSM项目的方法，终于习得了SSM项目搭建的方法，接下来我会记录一次我自己搭建SSM项目的过程。

目录

1.概述

  SSM项目的搭建实际上是Spring，Spring MVC与MyBatis三个框架的整合，听上去好像有点复杂，但是实际上其原理非常简单，就是在一个项目中先后配置这三个框架并构建相应的层，然后再在xml配置文件中加入三者的监听器，这样三个框架就能被xml配置文件联系在一起，Spring MVC中主要是提供了控制层的Servlet的方便服务，MyBatis中做的事情则主要是关于数据库的操作方便化，Spring则是提供了控制权反转和面向切面编程的功能，让这个项目的耦合度更低，达到了解耦的目的，其思想实际上是穿插在这个项目的各个层级之中的。

  SSM项目中分为如下几层：controller层，这层属于Spring MVC架构的管理范围，主要是负责请求的接收与发送，也就是我们的Servlet，里边提供操作简单的传参与转发功能；model层(entity)层，关于这层在Spring MVC和MyBatis两个框架中都有提及，在MyBatis中多被称为entity层，在Spring MVC中多被称为model层，在SSM项目中我们可以二选一，因为两个名字其实是一个东西，该层中存在的内容主要是项目中需要使用到的Java Bean对应的类，也就是Java Bean的定义信息或者说是蓝图；Service层，该层主要被Spring框架管理，该层明显的使用到了IOC的对象生成方法进行解耦，这层主要负责项目中的业务处理，也就是数据的逻辑操作；Dao层，该层也可以被称为mapper层，被MyBatis管辖，两个名字实际上指的是同一个东西，但是在我们配置该层的时候实际上也使用到了Spring提供的IOC思想，并且该层会分为两部分：接口部分和实现部分，实现部分我们通常是使用配置文件实现的，因此两部分通常不会在一起，为了区分，我们通常将配置文件命名为mapper部分，将接口部分命名为dao部分，二者共同组成mapper层或者说是dao层，需要注意的是在mybatis中还存在注解开发，注解开发中的实现和接口位于同一文件中，使用注解开发我们能更清晰的意识到二者属于同一层，但是我们很少使用注解开发吗，因为这样会提升耦合度。

  在SSM项目中model层有时可能也被称为java bean，而不认为它是一层，这里并不影响项目搭建，大家怎样理解都可以。

2.项目搭建

2.1.创建一个webapp模板的maven项目

  首先我们在IDEA中创建一个webapp模板的maven项目，名字随意，设定好工作坐标以及我们自己的maven路径，下面为步骤图解：

1.选择模板并创建项目

2.设定项目名称并设置工作坐标

3.设置maven路径与配置文件，之后点击finish就配置好了

2.2.导入jar包依赖

  之后我们进入项目后，最先显示的就是我们的pom文件，我们接下来需要对pom文件做一些操作：

1.删除用不到的坐标依赖，我们删除掉原有的properties标签、dependencies标签和build标签中的所有内容

2.导入我们即将用到的坐标依赖

  我们导入下面的jar包依赖：

<properties>

  <spring.version>5.0.2.RELEASE</spring.version>

  <slf4j.version>1.6.6</slf4j.version>

  <log4j.version>1.2.12</log4j.version>

  <mysql.version>5.1.6</mysql.version>

  <mybatis.version>3.4.5</mybatis.version>

  <jackson.version>2.9.4</jackson.version>

</properties>

<dependencies>

  <!--spring-->

  <dependency>

    <groupId>org.aspectj</groupId>

    <artifactId>aspectjweaver</artifactId>

    <version>1.6.8</version>

  </dependency>

  <dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-aop</artifactId>

    <version>${spring.version}</version>

  </dependency><dependency>

  <groupId>org.springframework</groupId>

  <artifactId>spring-context</artifactId>

  <version>${spring.version}</version>

</dependency>

  <dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-web</artifactId>

    <version>${spring.version}</version>

  </dependency>

  <dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-webmvc</artifactId>

    <version>${spring.version}</version>

  </dependency>

  <dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-test</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>

  <dependency>

    <groupId>junit</groupId>

    <artifactId>junit</artifactId>

    <version>4.12</version>

    <scope>test</scope>

  </dependency>

  <dependency>

    <groupId>mysql</groupId>

    <artifactId>mysql-connector-java</artifactId>

    <version>${mysql.version}</version>

  </dependency>

  <dependency>

    <groupId>javax.servlet</groupId>

    <artifactId>servlet-api</artifactId>

    <version>2.5</version>

    <scope>provided</scope>

  </dependency>

  <dependency>

    <groupId>javax.servlet.jsp</groupId>

    <artifactId>jsp-api</artifactId>

    <version>2.0</version>

    <scope>provided</scope>

  </dependency>

  <dependency>

    <groupId>jstl</groupId>

    <artifactId>jstl</artifactId>

    <version>1.2</version>

  </dependency>

  <!--log start-->

  <dependency>

    <groupId>log4j</groupId>

    <artifactId>log4j</artifactId>

    <version>${log4j.version}</version>

  </dependency>

  <dependency>

    <groupId>org.slf4j</groupId>

    <artifactId>slf4j-api</artifactId>

    <version>${slf4j.version}</version>

  </dependency>

  <dependency>

    <groupId>org.slf4j</groupId>

    <artifactId>slf4j-log4j12</artifactId>

    <version>${slf4j.version}</version>

  </dependency>

  <!-- log end-->

  <dependency>

    <groupId>org.mybatis</groupId>

    <artifactId>mybatis</artifactId>

    <version>${mybatis.version}</version>

  </dependency>

  <dependency>

    <groupId>org.mybatis</groupId>

    <artifactId>mybatis-spring</artifactId>

    <version>1.3.0</version>

  </dependency>

  <!--连接池-->

  <dependency>

    <groupId>com.alibaba</groupId>

    <artifactId>druid</artifactId>

    <version>1.1.10</version></dependency>

  <dependency>

    <groupId>org.mybatis.generator</groupId>

    <artifactId>mybatis-generator-core</artifactId>

    <version>1.3.5</version>

  </dependency>

  <dependency>

    <groupId>com.fasterxml.jackson.core</groupId>

    <artifactId>jackson-core</artifactId>

    <version>${jackson.version}</version>

  </dependency>

  <dependency>

    <groupId>com.fasterxml.jackson.core</groupId>

    <artifactId>jackson-databind</artifactId>

    <version>${jackson.version}</version>

  </dependency>

  <dependency>

    <groupId>com.github.pagehelper</groupId>

    <artifactId>pagehelper</artifactId>

    <version>5.1.10</version>

  </dependency>

  <dependency>

    <groupId>cn.hutool</groupId>

    <artifactId>hutool-all</artifactId>

    <version>5.2.3</version>

  </dependency>

  <dependency>

      <groupId>org.thymeleaf</groupId>

      <artifactId>thymeleaf-spring4</artifactId>

      <version>3.0.9.RELEASE</version>

  </dependency>

</dependencies>

<build>

  <finalName>ssm</finalName>

  <pluginManagement>

    <plugins>

      <plugin>

        <groupId>org.apache.maven.plugins</groupId>

        <artifactId>maven-compiler-plugin</artifactId>

        <version>3.2</version>

        <configuration>

          <source>1.8</source>

          <target>1.8</target>

          <encoding>UTF-8</encoding>

          <showWarnings>true</showWarnings>

        </configuration>

      </plugin>

    </plugins>

  </pluginManagement>

  <plugins>

    <plugin>

      <groupId>org.mybatis.generator</groupId>

      <artifactId>mybatis-generator-maven-plugin</artifactId>

      <version>1.3.5</version>

      <!--告诉插件，配置文件所在的位置-->

      <configuration>

        <configurationFile>src/main/resources/mbg.xml</configurationFile>

        <verbose>true</verbose>

        <overwrite>true</overwrite>

      </configuration>

    </plugin>

  </plugins>

</build>

  导入好之后我们点击更新来进行依赖的导入：

  命令行中输出如下信息说明我们已经导入成功了：

2.3.搭建项目基本框架

1.创建我们的Java程序目录与资源目录

  我们首先要在项目的main目录下创建两个目录，一个是java目录，一个是resource目录，两个目录都应被设定相应的角色，我们要把java目录设定成java源目录，将资源目录设定为资源目录，如下图所示我们分别创建这两个目录：

  我们创建好目录之后右键单击目录，就会出现一个菜单栏，我们在最下边的Mark Directory as选项中可以看到我们可以设定目录的类型，其中java目录应为最上边的Source Root也就是源根，resource目录应为第三个Resource Root也就是资源根，如图所示：

  两个目录创建好之后我们便得到了一个这样的目录结构，注意两个目录的类型千万不要设置错，图标要和我一样才行：

2.创建我们的Java工作空间

  我们显然是不能直接在java目录之下直接写java代码的，我们不能直接将代码写在一个目录之下，而是应该写在有着特定命名格式的包里。尽管包也是目录，但是我们通常认为包与普通的源目录有着本质上的区别，因此我们首先在java目录下创建一个和我们之前定义的工作空间同名的包，这是规范，我们之前定义的工作空间可以去2.1中查看，我定义的坐标名是com.spruce，这个名称通常是公司名或者组名，以后我们参与到实际的开发中之后会有更深入的了解：

3.创建测试区

  我们不仅仅要创建工作空间，我们还要创建测试空间，测试空间是和main目录同级别的一个目录，我们的主要测试代码都在里边书写，我们接下来在src目录下创建一个名为test的目录，并建立和main目录基本上一致的目录结构，test目录中无需创建webapp目录，只需创建好java目录与resource目录，其中，java目录的类型为Test Source Root也就是测试源根；resource目录的类型我们要定义为Test Resource Root，也就是测试资源根：

  下图中的第一个选项即为测试源根，第三个为测试资源根，他们与源根和资源根的图标是不一样的：

  创建好之后的目录结构如图所示：

  这样一来这个项目的准备工作就基本完成了，现在就可以进行我们项目的基本搭建了。

2.4.创建项目对应的数据库

  每一个SSM项目必然是要连接一个属于自己的数据库的，因此我们要专门为这个项目创建一个自己的数据库，这个数据库在之后的项目开发中必然会用到，而且在做测试的时候我们也会用到这个数据库，因此我们搭建一个和项目同名的数据库，项目名是train0429lrb，因此我们搭建一个和项目同名的数据库：

  我们使用Navicat创建一个数据库，字符集如图所示，需要注意的是有时我们即使设置了utf-8的格式，编码也是总出问题，而我的电脑不知咋回事一定会出现编码问题，因此在项目搭建过程中我们先忽略这个编码问题，在项目搭建完成后我们再着重解决这个问题。

  创建好数据库后我们在数据库中创建一个测试用的表，并且往里边放上一些数据，我们使用下面的数据创建表，也可以用Navicat的图形用户界面创建：

create table account(

	id int primary key auto_increment,

	name varchar(20),

	money double

);

  创建好之后是这样的：

  现在我们往里边插入一点数据：

  这样一来数据库就搭建好了，接下来我们根据数据库来创建我们的model层。

2.5.创建model层

  这里我想提的一点就是实际上每个逻辑层本质上都仅仅是一个包，其意义实际上是我们赋予它的，这里的思想实际上就是约定大于配置，对于这些层我们无需配置什么，而是我们要按照约定在里边些什么，我们在里边写的东西，就是我们赋予其真正含义的过程，我们在一个名为model的包下写Service层的代码，那这个包就是Service层的包。因此我们要是想创建一个层，必须要有代码的具体依托，而我们的代码在SSM项目中很大程度上是依托于数据库书写的，典型的如model层，接下来我们书写model层的代码。

  model层代码实际上就是java bean的蓝图，我们当前数据库中存在一个实体为account，因此我们就需要创建一个account的java bean蓝图，也就是Account类，经过上面的构建表我们知道数据库中的account表有三个字段：id[类型为int]、name[类型为varchar]、money[类型为double]，因此我们必须创建一个字段名和属性完全与该表一样的类，这个类在哪创建呢？我们首先应该在com.spruce下创建一个新包，名为model，然后今后它就是我们的model层了，之后我们在这个里边创建Account类：

  然后我们为其生成getter方法和setter方法，以及toString方法：

  创建好model层之后，我们整体项目就算出现了第一个约定了，根据这个约定，我们就可以配置三个框架以及它们相对应的层了。

2.6.Spring框架的导入以及Service层的创建

1.创建Service层

  Service是严格遵循Spring提供的IOC思路书写的，因此我们会将代码分为两部分，其中一部分是接口部分，另一部分是方法体部分，其中接口部分的作用主要是限制我们方法的声明，以及在controller层中提供生成标准bean的服务，首先我们先在com.spruce下创建一个service包：

  然后我们在其下边创建两个包，具体命名方式无所谓，主要是我们自己能区分就好了，一个包装接口，一个包装service层方法，如下：

  然后我们在interf包下创建一个新的接口类，名为AccountService，这里边定义的是Account这个javabean相关的业务操作的各种方法，我们书写其代码如下：

package com.spruce.service.interf;

import com.spruce.model.Account;

import java.util.List;

public interface AccountService {

    //查询所有

    public List<Account> findAll();

}

  这些代码意味着我们为AccountService的业务方法中定下了一个标准，简而言之就是说我们必须为Account这个实体提供一个查询所有数据库中的信息的方法。有了接口之后，我们就得在impl包中书写接口的实现，否则我们的方法是使用不了的。

  之后我们书写接口的实现，我们在impl包中创建一个与刚才的AccountService相对应的AccountServiceImpl类，然后让这个类实现那个接口，如下：

  通常情况下，我们在这个方法中是需要使用依赖注入的方式生成一个Dao层对象，然后使用Dao层对象中的那个方法的，但是现在我们还没有创建Dao层对象，因此我们先书写一个假方法，我们使用Spring提供的IOC尝试实例化AccountService类，我们现在里边书写如下方法：

@Override

    public List<Account> findAll() {

        System.out.println("业务层：查询所有");

        return null;

    }

  最后也是最终要的一点，我们为这个类加上注解@Service，加上这个注解之后，Spring才会扫描到这个类并承认这个类在Spring中存在的资格，之后才能生产这个类的对象，我们可以简单的记作加上注解之后，就可以使用Spring生成它的对象了，Spring中提供的对象生成许可注解有四种：@Component、@Controller、@Service、@Repository，这四个注解的功能都一样，就是创建对象，我们有时甚至可以混用，但是在SSM中我们尽量不要混用，因为这四个注解是分别面向不同的层的对象生成的，如下所示：

  因此我们在这里一定要为我们书写的这个实现类加上@Service注解，如图所示：

  代码如下：

package com.spruce.service.impl;

import com.spruce.model.Account;

import com.spruce.service.interf.AccountService;

import org.springframework.stereotype.Service;

import java.util.List;

@Service

public class AccountServiceImpl implements AccountService {

    @Override

    public List<Account> findAll() {

        System.out.println("业务层：查询所有");

        return null;

    }

}

2.创建Spring配置文件

  之后我们来正式配置Spring，我们首先创建配置文件，我们在之前在main中创建好的resource目录下新建一个spring目录，并在里边创建一个spring config类型的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"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--开启注解扫描，要扫描的是service-->

    <context:component-scan base-package=""/>

</beans>

  其中在<context:component-scan base-package=""/>中，我们为base-package添加属性，这个属性是一个包路径，内容是我们所想要让Spring托管的包，我们填入com.spruce，意思是将整个工程中的类都纳入其管理，我们可以根据自己的需求来缩小这个范围：

  之后我们的Spring就配置好了，是的就是这么简单，接下来我们进行测试。

3.测试Spring

  我们使用Spring的目的在于让Spring为我们生成对象，因此我们要测试这个功能，我们在test下的Java中创建一个和工作空间同名的包com.spruce，并在下面创建一个TestSpring类，如下：

  我们在里边放入如下代码：

package com.spruce;

import com.spruce.service.interf.AccountService;

import org.junit.Test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {

    @Test

    public void run(){

        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring/spring.xml");//这里是spring.xml的路径，我们一定要书写对，该路径是以resource为出发点的相对路径，我们的目录结构中spring.xml放在了spring目录下，因此这里应该这样书写

        AccountService service = ac.getBean(AccountService.class);

        service.findAll();

    }

}

  这段代码就是测试一下Spring的IOC功能是否能用，我们点击test提供的运行按钮尝试一下：

  我们书写的假方法运行成功了，这说明类的对象被成功创建了，Spring层搭建成功！

2.7.Spring MVC框架的导入以及controller层的创建

  接下来我们开始创建controller层以及导入Spring MVC框架，Spring MVC支持的controller层主要也是使用IOC进行解耦，并且主要功能是实现请求的收发以及页面跳转的，整个项目的逻辑归他控制因此我们叫它控制层，接下来我们首先要配置Spring MVC。

1.Spring MVC框架的导入

  关于Spring MVC框架的导入我们可以直接看我之前写的这篇笔记：Spring MVC复习 —— 搭建Spring MVC项目 - 云杉木屋 - 博客园 (cnblogs.com)，在这里我们也重复的做一下。

  首先我们将webapp中的web.xml配置信息换一下，我们换成这个：

<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

 </web-app>

  然后我们在里边插入如下配置信息，配置我们的各种需要的工具：

<!--在web.xml中配置Spring提供的过滤器类 -->

<filter>

    <filter-name>encodingFilter</filter-name>

    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

    <async-supported>true</async-supported>

    <init-param>

        <param-name>encoding</param-name>

        <param-value>UTF-8</param-value>

    </init-param>

</filter>

<filter-mapping>

    <filter-name>encodingFilter</filter-name>

    <url-pattern>/*</url-pattern>

</filter-mapping>

<!--不拦截所有是html的页面请求-->

<servlet-mapping>

    <servlet-name>default</servlet-name>

    <url-pattern>*.html</url-pattern>

</servlet-mapping>

<!--配置前端控制器，对浏览器发送的请求进行统一处理-->

<servlet>

    <servlet-name>dispatcherServlet</servlet-name>

    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <!--加载springmvc.xml配置文件的位置和名称，配置的是Spring配置-->

    <init-param>

        <!--contextConfigLocation:上下文配置路径，固定值-->

        <param-name>contextConfigLocation</param-name>

        <!--classpath:类路径，值得是Java和resources文件夹-->

        <!--springmvc.xml:指的是配置文件的名称：需要配置springmvc.xml，在下面-->

        <param-value>classpath:springmvc.xml</param-value>

    </init-param>

    <!--配置启动加载-->

    <load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

    <servlet-name>dispatcherServlet</servlet-name>

    <url-pattern>/</url-pattern>

</servlet-mapping>

<!--开启项目时打开的页面-->

<welcome-file-list>

    <welcome-file>/index.html</welcome-file>

</welcome-file-list>

  配置好之后的代码是这样的(直接把下面的代码完全粘贴在web.xml中也行)：

<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

  <!--在web.xml中配置Spring提供的过滤器类 -->

  <filter>

    <filter-name>encodingFilter</filter-name>

    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

    <async-supported>true</async-supported>

    <init-param>

      <param-name>encoding</param-name>

      <param-value>UTF-8</param-value>

    </init-param>

  </filter>

  <filter-mapping>

    <filter-name>encodingFilter</filter-name>

    <url-pattern>/*</url-pattern>

  </filter-mapping>

  <!--不拦截所有是html的页面请求-->

  <servlet-mapping>

    <servlet-name>default</servlet-name>

    <url-pattern>*.html</url-pattern>

  </servlet-mapping>

  <!--配置前端控制器，对浏览器发送的请求进行统一处理-->

  <servlet>

    <servlet-name>dispatcherServlet</servlet-name>

    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <!--加载springmvc.xml配置文件的位置和名称，配置的是Spring配置-->

    <init-param>

      <!--contextConfigLocation:上下文配置路径，固定值-->

      <param-name>contextConfigLocation</param-name>

      <!--classpath:类路径，值得是Java和resources文件夹-->

      <!--springmvc.xml:指的是配置文件的名称：需要配置springmvc.xml，在下面-->

      <param-value>classpath:springmvc.xml</param-value>

    </init-param>

    <!--配置启动加载-->

    <load-on-startup>1</load-on-startup>

  </servlet>

  <servlet-mapping>

    <servlet-name>dispatcherServlet</servlet-name>

    <url-pattern>/</url-pattern>

  </servlet-mapping>

  <!--开启项目时打开的页面-->

  <welcome-file-list>

    <welcome-file>/index.html</welcome-file>

  </welcome-file-list>

</web-app>

  配置好之后我们会发现有个地方标红：

  这是springmvc.xml文件的引用路径，加入这个配置信息意在监听Spring MVC的配置文件，以便于将Spring MVC整合进项目，现在我们还没有创建这个配置文件，因此它标红了，现在我们创建它，我们在resource目录下创建一个新的目录，明明为springMVC，然后在其下边创建springmvc.xml配置文件：

  我们直接将下面的配置信息粘贴进去：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:mvc="http://www.springframework.org/schema/mvc"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/mvc

http://www.springframework.org/schema/mvc/spring-mvc.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

   <!--配置spring创建容器时要扫描的包-->

<context:component-scan base-package=""/>

<!--处理映射器-->

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

<!--处理器适配器-->

<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

<!--配置视图解析器-->

<bean id="viewResolver" class="org.thymeleaf.spring4.view.ThymeleafViewResolver">

    <property name="order" value="1"/>

    <property name="characterEncoding" value="UTF-8"/>

    <property name="templateEngine" ref="templateEngine"/>

</bean>

<!-- templateEngine -->

<bean id="templateEngine" class="org.thymeleaf.spring4.SpringTemplateEngine">

    <property name="templateResolver" ref="templateResolver"/>

</bean>

<bean id="templateResolver" class="org.thymeleaf.spring4.templateresolver.SpringResourceTemplateResolver">

    <property name="prefix" value="/html/" />

    <property name="suffix" value=".html" />

    <property name="templateMode" value="HTML5"/>

</bean>

<!-- 配置spring开启注解mvc的支持  默认就是开启的 ，要想让其他组件（不包含映射器、适配器、处理器）生效就必须需要配置了-->

<mvc:annotation-driven/>

</beans>

  其中这里有一个和Spring配置文件中一样的标签<context:component-scan base-package=""/>，我们在此同样要书写我们的com.spruce路径：

  这里根据你的工作空间具体命名确定，只是我的工作空间名称为com.spruce，这里才这样填的。之后Spring MVC就相当于引入了，我们还要搭建相关的层以及目录结构对其进行测试。

2.搭建相关目录结构

  在springmvc.xml中有这样一个标签：

<bean id="templateResolver" class="org.thymeleaf.spring4.templateresolver.SpringResourceTemplateResolver">

    <property name="prefix" value="/html/" /> <!--页面跳转时，路径的前缀，可以理解为我们的页面必须放在的目录的名字-->

    <property name="suffix" value=".html" /> <!--页面跳转时，路径的后缀，也就是规定了我们页面文件的类型-->

    <property name="templateMode" value="HTML5"/> <!--我们页面使用到的前端规范，现在都用h5了，所以我们在这里也用h5-->

</bean>

  这里边规定的东西是我们项目中的页面信息，在Spring MVC中页面跳转实际上使用到了一个字符串拼接的方式，controller层中的方法返回一个字符，然后根据这里的配置信息进行拼接，然后根据拼接好的字符串进行定位，所以第二三行中都是页面跳转时用到的信息标签，其中第二行是路径的前缀，它意味着我们的controller层中的方法返回了一个字符串之后，在字符串拼接的时候会首先在它前边加上/html/，而第三行中的则是后缀，它意味着会在该字符串的最后加上.html，举个例子，就是说我们的controller层中返回了一个“suc”，我们就会得到一个这样的字符串“/html/suc.html”，这个字符串意味着以webapp目录为起点的绝对定位下的html目录下的suc.html文件。

  根据这个信息，我们首先要在webapp目录下创建一个叫html的文件来保存我们的html文件：

  同时web.xml中还配置了欢迎页面：

  其路径是以webapp为起点的绝对路径：/index.html，我们的项目中没有这个文件，只有一个index.jsp，jsp文件现在已经不常用了，因此我们把它换成index.html文件，并在里边书写上如下的代码：

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>主页</title>

</head>

<body>

<html>

<head>

    <meta charset="utf-8">

    <title>入门程序</title>

</head>

<body>

<h3>入门</h3><a href="/SSMDemo/hello" >入门程序</a>

</body>

</html>

</body>

</html>

  之后我们的页面相关事项基本就处理好了，我们接下来书写controller层。

3.controller层及相关文件配置

  我们首先要在com.spruce下面创建一个名为controller的包：

  然后我们在这个包里创建我们相关的controller类就行了，我们现在新建一个名为AccountController的类，如图所示：

  之后我们将Spring MVC整合到Spring中去，方法为将如下代码粘贴到web.xml文件中去：

<!--配置Spring的监听器-->

<display-name>Archetype Created Web Application</display-name>

<listener>

  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<!--配置加载类路径的配置文件-->

<context-param>

  <param-name>contextConfigLocation</param-name>

  <param-value>classpath:spring.xml</param-value>

</context-param>

  粘贴好之后如图所示：

  两个报错的地方是因为路径不对，我们改一下路径即可：

  之后我们在AccountController中粘贴如下的代码：

package com.spruce.controller;

import com.spruce.service.interf.AccountService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.RequestMapping;

@Controller

@RequestMapping("/account")

public class AccountController {

    @Autowired

    private AccountService accountService;

    /**

     * 处理超链接发送出来的请求

     * @param model

     * @return

     */

    @RequestMapping(path = "/hello")

    public String sayHello(Model model){

        System.out.println("入门方法执行了2...");

        // 向模型中添加属性msg与值，可以在html页面中取出并渲染

        model.addAttribute("msg","hello,SpringMVC");

        // 配置了视图解析器后，写法

        return "suc";

    }

}

  其中我们在代码的的上边加入了一个注解@Autowired，这个注解的意思是依赖注入，也就是让spring为其生成一个对象，我们就无需自己生成对象了，在之后我们就可以直接调用这个对象的方法了，这个对象是AccountService接口类型的，在生成对象的时候，Spring会根据Service的接口及实现方式生产一个新对象，新对象是使用多态的方式(实际上二者结构完全一致，因此并没有明显体现多态的含义)生成了一个接口类型的对象，我们只需调用这个对象，就可以规范的使用我们之前定义的方法。我们必须完成上边的整合步骤之后，才能使用这个依赖注入的功能。

  上边我们整合配置的目的在于：在controller中能成功的调用service对象中的方法。方法原理是： 在web.xml中配置ContextLoaderListener监听器，该监听器默认加载WEB-INF目录下的applicationContext.xml的配置文件，我们修改全局的路径变量:，进而让加载的文件变成我们的目标文件，这样一来，在项目启动的时候，就去加载spring.xml的配置文件了，而我们的spring就可以直接在这里使用了。

  在上面的controller代码中，类上边的@Controller代表该类被Spring托管来产生对象，这个对象的调用则是被Spring MVC申请的，这个对象的调用将使用反射的方式在我们进行Servlet请求的时候隐性的被调用，而@RequestMapping("/account")则是其Servlet请求路径，这是一级路径，里边的方法上的注解@RequestMapping(path = "/hello")是二级路径，它们用来进行精确寻址。而这个方法的返回值"suc"，在Spring MVC中被默认解析为一个路径，也就是上边我们提到的文件路径，它返回之后将被拼接成一个完整的路径，用于寻找页面视图。我们在上边配置的是html目录下的html类型文件，因此为了让这个返回有地方可去，我们在html目录下创建一个suc.html，并书写如下代码：

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>成功页面</title>

</head>

<body>

    你好，我是成功页面!

</body>

</html>

  之后关于controller层的东西就基本上创建好了，我们为该项目配置上Tomcat服务器，然后进行测试。

4.配置Tomcat服务器

  首先我们点击这里：

  我们点击第一个选项：

  之后就会弹出一个这样的框：

  点击加号：

  我们选择Tomcat下的local：

  之后就会进入如下界面：

  点击Deployment按钮之后，我们就会进入下面的选项：

  点击下图中箭头指向的加号：

  点击第一个选项：

  选择第二个选项：

  报错就会消失并出现如下的栏目：

  我们发现新出现的栏目中是一串字符，内容是我们的项目名称_war_exploded，我们删除掉_war_exploded部分，让这里的内容变成我们的项目名称：

  然后点击Apply->OK之后就好了。

5.测试

  我们直接点击绿色箭头让Tomcat运行起来：

  我们首先就会进入之前配置好的index.html页面，如下：

  之后我们点击入门程序，进行跳转，根据上面我们书写的代码，我们知道点击这个连接会触发我们写好的servlet程序，并进行寻址，找到account/hello并执行，这个代码在controller层，这个代码会让我们跳转到html/suc.html，我们点点看：

  拉垮了，不行，这是为什么？404错误意思是url路径错误，还记得我们在上面的步骤中，就是在书写index.html页面的代码中做了一个提示吗，问题就出在那里，我们的请求路径没写对，现在我把那个代码拿到这里来看：

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>主页</title>

</head>

<body>

<html>

<head>

    <meta charset="utf-8">

    <title>入门程序</title>

</head>

<body>

<h3>入门</h3><a href="/SSMDemo/hello" >入门程序</a>

</body>

</html>

</body>

</html>

  我们的路径是"/SSMDemo/hello"，第一级目录是"SSMDemo"，这是我们的项目名，我这里的代码因为是直接复制的老师给我的，这个项目名是老师的项目名所以错了。那么我们改成我们自己的“/train0429lrb/hello”就行了吗？答案还是不行，我们应该应该还记得我们在书写controller的时候还配置了一个二级路径，第一级为account，这个路径给在了类上，而hello才是给定在了方法上，这里这个跳转我们是想调用那个方法，那就应该把路径写全进行精确调用，因此路径应该是这样：“/train0429lrb/account/hello”，我们的index.html代码应该是这样：

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>主页</title>

</head>

<body>

<html>

<head>

    <meta charset="utf-8">

    <title>入门程序</title>

</head>

<body>

<h3>入门</h3><a href="/train0429lrb/account/hello" >入门程序</a>

</body>

</html>

</body>

</html>

  我们重启项目再次测试：

  跳转成功！尽管有乱码错误，但是根据我们最后书写的那个感叹号，我们可以依稀判断出，这句话就是我们在suc.html中书写的：你好，我是成功页面!，关于编码问题，我会在文章的最后进行研究，这里如果你想让效果更明显的话，可以先改成英文，这样就不会出现乱码。

2.8.MyBatis框架的导入以及Dao层的创建

  现在我们来进行最后一个步骤的配置，这个步骤的配置可能比较繁琐，我们现在来配置Dao层和MyBatis框架。

1.创建数据库信息配置文件

  我们首先创建用来填写数据库信息的配置文件，我们可以将数据库信息直接填在xml文件中，也可以新建一个properties文件，然后将数据库信息放在这里边，在xml文件中用变量的形式来填写，两种方法均可，配置文件的方式更利于后人维护时更改，因此我们使用这种更为先进的方法，我们首先创建一个MyBatisConfig目录，然后在下面创建一个SqlMapConfig.xml文件，一个jdbc.properties文件：

  我们在jdbc.properties文件中书写下列信息：

driver=com.mysql.jdbc.Driver

url=jdbc:mysql://localhost:你的数据库服务端口名/你的数据库名称?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false

username=你的数据库用户名

password=你的数据库用户密码

initialSize=0

maxActive=20

maxIdle=20

minIdle=1

maxWait=60000

  然后我们在SqlMapConfig.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:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:mvc="http://www.springframework.org/schema/mvc"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

                        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

                        http://www.springframework.org/schema/context

                        http://www.springframework.org/schema/context/spring-context-3.1.xsd

                        http://www.springframework.org/schema/mvc

                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

    <!-- 自动扫描 -->

    <context:component-scan base-package="com.spruce" /> <!--MyBatis托管的包路径--> 

    <!-- 引入配置文件 -->

    <bean id="propertyConfigurer"

        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

        <property name="location" value="classpath:jdbc.properties" />

    </bean>  

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

        destroy-method="close">

        <property name="driverClassName" value="${driver}" />

        <property name="url" value="${url}" />

        <property name="username" value="${username}" />

        <property name="password" value="${password}" />

        <!-- 初始化连接大小 -->

        <property name="initialSize" value="${initialSize}"></property>

        <!-- 连接池最大数量 -->

        <property name="maxActive" value="${maxActive}"></property>

        <!-- 连接池最大空闲 -->

        <property name="maxIdle" value="${maxIdle}"></property>

        <!-- 连接池最小空闲 -->

        <property name="minIdle" value="${minIdle}"></property>

        <!-- 获取连接最大等待时间 -->

        <property name="maxWait" value="${maxWait}"></property>

    </bean>  

    <!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

        <property name="dataSource" ref="dataSource" />

        <!-- 自动扫描mapping.xml文件 -->

        <property name="mapperLocations" value="classpath:mapping/*.xml"></property>  <!--你的mapper类型的xml文件路径-->

    </bean>  

     <!-- DAO接口所在包名，Spring会自动查找其下的类 -->

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">

        <property name="basePackage" value="com.spruce.dao" />  <!--你的dao层接口路径-->

        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>

    </bean>

    <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->

    <bean id="transactionManager"

        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="dataSource" />

    </bean>  

</beans>

  这是一个比较完善的MyBatis配置文件，以后我们可以直接使用它作为模板，现在我们复制进入：

  配置文件出报错是因为我们的路径有误，而下面的类找不到问题则是我们没有导入commons-dbcp.jar包，我们逐一修正这些问题，我们在pom文件的坐标依赖中加入下面的语句：

<dependency>

      <groupId>commons-dbcp</groupId>

      <artifactId>commons-dbcp</artifactId>

      <version>1.4</version>

</dependency>

  之后就好了：

  需要注意的是这个包不能导入太新的，太新的里边去掉了这个类，导致仍然报错，我们使用1.4版本就完全没问题。(这些东西已经上升到玄学的约定问题了，没有一定之规，只要不报错就能用)

  最后我们还有一个检测mapper类型配置文件的位置也报错，这是因为我们还没有创建这个目录：

  我们现在来创建这个目录：

  等我们往里边创建了实现数据操作的xml配置文件之后就完全不会报错了，这个属于下个步骤的内容。

2.搭建Dao层

  Dao层分为两部分，一部分为Dao层接口，一部分为mapping中的实现配置文件，我们现在都没创建，我们先创建Dao层接口，我们现在com.spruce下创建一个新包：dao

  然后我们在里边书写一个针对account的dao层接口类AccountDao：

  如上图所示我们创建好了Dao层的接口，需要注意的是在配置文件中，MyBatis里边也需要用到Spring对Dao层的类进行托管，这个托管的作用是使用IOC的思想生成Dao层对象时用到的。之后我们在Dao层中的接口下书写如下代码：

package com.spruce.dao;

import com.spruce.model.Account;

import java.util.List;

public interface AccountDao {

    public List<Account> findAll();

}

  然后我们在mapping中书写一个关于Account的全览方式的实现：

  之后Dao层就创建好了，最后我们将MyBatis加入到Spring的配置文件中去，我们将将如下代码复制到web.xml文件中去：

<!-- 配置加载类路径下的applicationContext.xml配置文件 -->

<context-param>

    <param-name>contextConfigLocation</param-name>

    <param-value>classpath:applicationContext.xml</param-value>

</context-param>

<!-- 配置监听器-->

<listener>

    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

  需注意的是我们如果直接将这个代码复制进去的话必定报错，这是因为我们已经配置过一个监听器了，mybatis的监听器和spring的监听器重名了，因此我们首先需要给mybatis的监听器改个名字，然后直接将它复制进去即可：

<!-- 配置加载类路径下的applicationContext.xml配置文件 -->

<context-param>

    <param-name>contextConfigLocation1</param-name>

    <param-value>classpath:applicationContext.xml</param-value>

</context-param>

  但是，这种方式万万不行的，初学的我天真的以为这样就行了，实际上不行，我亲自尝试的结果告诉我们，这种方法是错误的，且说出来会被嘲笑，这是因为这个监听器只能监听这个contextConfigLocation名字的文件，如果这么写的话会导致整个mybatis无法使用，在创建dao层对象是，依赖注入出现问题：

  如果大家碰到这种问题那就是监听器没配置对，我们如何解决这个问题呢？我们对比之前书写的spring.xml和SqlMapConfig.xml会发现二者在开有一个标签是重复的：

  实际上，两个标签是同一个东西，就是Spring托管，因此我们完全可以将spring.xml删除掉，然后将其配置融入进mybatis的配置文件中：

  然后我们惊喜的发现这里就不报错了：

  因此在书写配置文件时，由于Spring的配置文件过于简单并且和其他的配置文件都是相容的，因此我们可以将Spring的配置文件书写进MyBatis的配置文件中去或者书写进Spring MVC的配置文件中去，我个人觉得书写进Spring MVC的里边更好一点。

  而实际上我已经这么做了，只不过是因为我刚才不懂，才会忽略这个部分。

2.9.测试

  我们现在开始测试：

1.书写Service层的方法

package com.spruce.service.impl;

import com.spruce.dao.AccountDao;

import com.spruce.model.Account;

import com.spruce.service.interf.AccountService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import java.util.List;

@Service

public class AccountServiceImpl implements AccountService {

    @Autowired

    public AccountDao accountDao;

    @Override

    public List<Account>  findAll() {

        System.out.println("业务层：查询所有");

        return this.accountDao.findAll();

    }

}

2.书写controller层的方法

package com.spruce.controller;

import com.spruce.model.Account;

import com.spruce.service.interf.AccountService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller

@RequestMapping(path = "/account")

public class AccountController {

    @Autowired

    private AccountService accountService;

    /**

     * 处理超链接发送出来的请求

     * @param model

     * @return

     */

    @RequestMapping(path = "/hello")

    public String sayHello(Model model){

        System.out.println("入门方法执行了2...");

        List<Account> accounts = accountService.findAll();

        for (Account account: accounts) {

            System.out.println(account.toString());

        }

        // 向模型中添加属性msg与值，可以在html页面中取出并渲染

        model.addAttribute("msg","hello,SpringMVC");

        // 配置了视图解析器后，写法

        return "suc";

    }

}

  根据逻辑，我们调用这个方法会使得控制台中输出我们的查询结果，我们运行尝试：

  执行成功！太感动了！我们整体上在controller层和service层使用了依赖注入，这两个地方的依赖注入都是依托的spring的IOC容器，整个项目的依赖注入都没问题说明我们的SSM项目已经整合成功，赛高泥嗨铁鸭子哒！！！！！！！

  在SSM项目整合成功之后我们就可以愉快的使用它进行开发了，使用SSM开发是一种非常简单的事情，我们只需创建两个接口然后写crud就行了，难一点的顶多是设置个懒加载，连接个LayUI，不过都无所谓了，都是简单的使用工具吗，而创建SSM项目却是一件让人血压飙升的事情，即使创建完成了，我也仍然是不太懂，还有更多的知识在等着我。

附录：关于编码的问题，我最终解决了，详情见下面的链接

  针对本项目的编码问题解决。

使用IDEA搭建SSM项目的更多相关文章

  1. Maven 搭建 SSM 项目 （oracle）

    简单谈一下maven搭建 ssm 项目 (使用数据库oracle,比 mysql 难,所以这里谈一下) 在创建maven 的web项目时,常常会缺了main/java , main/test 两个文件 ...

  2. 自动搭建ssm项目

    手把手教你搭建ssm项目 注意,必须修改:包名.数据库名称.账号.密码 注意:必须配置好第一次,“引入后”才能配置第二次 第一步:打开idea选择创建maven项目 import java.io.*; ...

  3. 搭建SSM项目时报错（org.springframework.jdbc.CannotGetJdbcConnectionException）

    严重: Servlet.service() for servlet [SpringMVC] in context with path [/ssm] threw exception [Request p ...

  4. 搭建ssm项目框架

    [声明]转载注明链接,源码联系公众号:aandb7获取 [此处组织名groupId:com.dayuanit,可替换公司域名:项目名artifactid:...] 此处第二个配置文件选择maven安装 ...

  5. 用idea搭建SSM项目，原来这么简单

    目录 前言 软件环境 创建项目 数据库文件 配置文件 pom.xml log4j.properties jdbc.properties applicationContext.xml spring-mv ...

  6. 模拟Springboot一:(零xml配置搭建SSM项目)

    在spring官网文档中无论是spring的基础文档,还是spring-mvc文档都推荐我们使用javaconfig的方式来搭建项目 间接说明 (优点:javaconfig配置>xml配置) 其 ...

  7. Spring Boot2 系列教程(一)纯 Java 搭建 SSM 项目

    在 Spring Boot 项目中,正常来说是不存在 XML 配置,这是因为 Spring Boot 不推荐使用 XML ,注意,并非不支持,Spring Boot 推荐开发者使用 Java 配置来搭 ...

  8. （05节）快速搭建SSM项目

    1.1  快速搭建Web项目 注意点:name:archetypeCatalog,value:internal 原因:Intellij IDEA根据maven archetype的本质,执行mvn a ...

  9. 记录搭建ssm项目

    搞java也快3年了,搭建一个ssm居然有点吃力. 参考链接:https://blog.csdn.net/gebitan505/article/details/44455235/ 环境准备:jdk8. ...

  10. 搭建SSM项目框架全过程及思考

    1.前言 之前都是在现有框架下进行写代码或者总是看一些别人的架构,总会眼高手低.于是打算自己完整的走一遍流程,同时把所遇到的问题,思考的问题记下来,供大家参考.由于是工作年限不高,属于新手,不足之处还 ...

随机推荐

  1. mybatisPlus在Springboot中的使用

    文章目录 1.简介 2.支持的数据库 3.框架 4.创建一个springboot项目 4.1 .pom文件中加入依赖 4.2.yml文件的配置 4.3 .数据库脚本 4.4.实体类 4.5 .启动类添 ...

  2. Redis 常见问题-缓存穿透

    问题描述: * 针对 DB 中不存在的数据源,每次请求缓存和数据库都不存在 造成后果: * 应用服务器压力变大 * Redis 命中率大幅度降低 * `数据库压力巨增甚至 down 掉`* 该现象对于 ...

  3. Linxu常用命令

    一.Linux权限的概念 Linux下有两种用户:普通用户和超级用户: 普通用户:在linux下做有限的事情: 超级用户:可以在linux系统下做任何事情,不受限制. 普通用户的提示符是"$ ...

  4. 三十二、kubernetes集群的网络实现

    Kubernetes集群的网络实现 CNI介绍及集群网络选型 容器网络接口(Container Network Interface),实现kubernetes集群的Pod网络通信及管理.包括: CNI ...

  5. JAVA学习前准备

    电脑常用快捷键 Ctrl+C:复制 Ctrl+V:粘贴 Ctrl+A:全选 Ctrl+X:剪切 Ctrl+Z:撤销 Ctrl+S:保存 Alt+F4:关闭窗口 Shift+delete:永久性删除文件 ...

  6. Spring Boot：自定义 Whitelabel 错误页面

    一.概述在本文中,我们将研究如何禁用和自定义 Spring Boot 应用程序的默认错误页面,因为正确的错误处理描述了专业性和质量工作. 2.禁用白标错误页面 首先,让我们看看如何通过将server. ...

  7. CSP-J2022 题解报告

    \(CSP-J2022\) 题解报告 \(T1\) 乘方: 发现 \(2^{32}>10^9\),所以这个题只需要特判 \(a=1\) 的情况为 \(1\),其他直接枚举再判断即可. Code: ...

  8. solidedge型材库/.sldlfp格式转.par

    一.打开solidworks型材库:D:\Program Files\SOLIDWORKS Corp\SOLIDWORKS\lang\chinese-simplified\weldment profi ...

  9. Go语言核心36讲31

    我们在前两篇文章中讨论了互斥锁.读写锁以及基于它们的条件变量,先来总结一下. 互斥锁是一个很有用的同步工具,它可以保证每一时刻进入临界区的goroutine只有一个.读写锁对共享资源的写操作和读操作则 ...

  10. 超精准！AI 结合邮件内容与附件的意图理解与分类！⛵

    作者:韩信子@ShowMeAI 深度学习实战系列:https://www.showmeai.tech/tutorials/42 TensorFlow 实战系列:https://www.showmeai ...