从零开始快速搭建SSM框架(附Demo源码)

公司业务需要让我去学后台接口,如果你回看我之前发布的文章会发现都是Android开发相关的内容,自己对写接口这事只有很浅的了解,因为Android经常要调用接口所以只知道客户端调用接口后的流程大概:

  1. 服务端接收请求参数
  2. 调用sql语句传入参数进行查询
  3. 得到查询结果
  4. 对查询结果做判断({"msg":"失败","code":"-1","data":""} or {"msg":"成功","code":"0","data":"xxxx"})
  5. 返回最终的数据给客户端

其他再深入的就不清楚了,用了1个半月时间看教程算是弄清楚怎么搭框架,遇到不少坑分享出来也方便日后自己回顾

说一下文章主要涉及到的知识点:

  1. 在IDEA生成的项目中接入SSM框架
  2. 用Hibernate框架生成数据库表
  3. 完成事务日志的回滚操作
  4. 通过拦截操作判断token是否过期
  5. mybatis写sql语句需要注意的地方
    (内容太多写不下会分两篇写,第一次接触后台的东西说错的地方欢迎指出)
    Demo源码地址

开发需要用到的软件

IDEA、TomCat、Navicat for Mysql、PostMan(网络调试工具,前期不需要用到)

配置一个带SpringMVC框架的项目

  1. 打开IDEA 新建一个带有SpringMVC框架的项目


    2631548312699_.pic_hd.jpg
  2. 输入项目名


    2621548312699_.pic_hd.jpg
  3. 点击下一步,然后等待后台完成下载Spring框架和初始化项目

  4. 如图打开web.xml 可以看到初始化完成后系统自动配置好的信息,这里有几个地方比较重要,请务必认真记下来,反正你后面会遇到很多疑问,一共圈了3个红框按顺序讲一下他们的作用:

2611548312699_.pic_hd.jpg
<context-param><!--配置上下文参数-->
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>声明上下文配置的文件路径
    </context-param>

要记得这个上下文的配置文件中(applicationContext.xml)配置的所有内容都是全局的(很重要,否者后面会遇到很多麻烦)

<servlet> <!--配置Spring-->
        <servlet-name>dispatcher</servlet-name>文件名(对应的文件指向的是dispatcher-servlet.xml)
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

这里要记得这里是配置Spring的,只对Spring框架起作用是局部的

<servlet-mapping><!--配置Spring的拦截规则-->
        <servlet-name>dispatcher</servlet-name> 要拦截的servlet名字,这里对应就是拦截上面的Spring
        <url-pattern>*.form</url-pattern> 拦截的规则这里只是个模板我们先改成*.do好了,表示拦截以'.do'结尾的url
    </servlet-mapping>
    <url-pattern>*.form</url-pattern>

以上的知识点很重要,如果到后面搞不清了很容易懵 切记~

配置Tomcat

点击如下图的地方,准备开始配置Tomcat
image.png

接着点击加号然后下滑到Tomcat Server 选中Local (请确保你已经在本机配置了Tomcat环境,否者这里不会出现此选项)

image.png
image.png
image.png

然后点击ok,回到代码编辑器,选择如下图的选项

image.png

如下图勾上Maven点击确定,回到编辑界面


image.png

这个时候会自动生成一个叫pom.xml的文件,这个文件的作用是管理项目的依赖(后面会详细讲到)


image.png

跟着下图点击,这里会出现缺少关于Spring的某些依赖文件,点击fix修复完成


image.png

如果fix完了没有配置没有其他异常,点击运行浏览器会打开如下界面


image.png

以上就配置完一个带有SpringMVC+Maven 的项目了


接下来说一下数据库环境,我用的是Naive for MySQL,这里不写教程了,很简单可以自己搜索.


image.png

回到项目新增一些配置文件


image.png
image.png

新建两个配置文件,第一个名字为 log4j.properties
里面的内容如下:

database.driver=com.mysql.jdbc.Driver 
database.url=jdbc:mysql://localhost:3306/XXXX?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true
database.username=root
database.password=root

database.maxActive=100
database.maxWait=30000
database.maxIdle=5
sqlSessionFactory.configLocation=classpath:/mybatis/mybatis-config.xml

说一下上面配置的作用
database.driver 数据库驱动,如果你的用的也是mysql,直接粘贴,其他数据库类型自行搜索
database.url 数据库的地址,如果你也是mysql,粘贴后把XXXX替换成你自己的数据库名字即可,后面拼接的参数建议留着
database.username 数据库连接名字
database.password 数据连接密码
剩下的不太重要不用管,后面有机会再做说明

新建第二个名字为:log4j.properties
里面的内容:

### set log levels ###
log4j.rootLogger = debug ,  stdout

### 输出到控制台 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

### 输出到日志文件 ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG ## 输出DEBUG级别以上的日志
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

这个配置文件是控制台打印日志的样式,直接粘贴就行

接下来把mybatis配置一下:


image.png

如图在WEB-INF文件夹下右键选择新建一个Spring Config文件,命名为applicationContext-myibatis.xml


image.png

关于这三个xml文件具体配置的内容后面会说到,最好按顺序往下看

HIbernate

如果你对sql建表有经验,并且对Hibernate没有兴趣可直接略过

为什么我要用Hibernate框架?
本身对sql语句不熟,Hibernate能通过注入和扫描把对应的类通过映射的方式生成数据库表(以后要长期做后台的还是建议学好sql语句)

接着来接入Hibernate框架

image.png

跟着上图的操作后在你项目的resource文件夹会自动生成一个hibernate.cfg.xml的文件,我们需要在这里配置一下

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
  <session-factory>

    <!--数据驱动我这里用的是mysql-->
    <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> 
    <!--数据库地址,把XXXX改成你自己的数据库名字-->
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/XXXXX?useUnicode=true&amp;characterEncoding=UTF-8</property>
    <property name="hibernate.connection.username">root</property>
    <property name="hibernate.connection.password">root</property>
     <!--每次执行Hibernate框架生成数据库表的策略,推荐用update-->
    <property name="hibernate.hbm2ddl.auto">update</property>
    <property name="hbm2ddl.auto">update</property>
     <!--是否把框架自动执行数据库语句时的过程(执行的sql语句)打印到控制台-->
    <property name="show_sql">true</property>
    <!-- List of XML mapping files -->



    <mapping class="com.Lipt0n.test.POJO.UserInfo"/><!--这个很重要,框架执行映射操作的类,这里要改成你自己的类所在的包名-->

  </session-factory>
</hibernate-configuration>

image.png

1..新建一个名为UpdateDB的类,这个类用来调用Hibernate框架执行映射操作
2.接着新建一个文件夹POJO,以后需要进行映射的类我们都会存放在这个文件夹

UpdateDB 代码如下:

package com.Lipt0n.test;

import org.hibernate.HibernateException;
import org.hibernate.Metamodel;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;

import javax.persistence.metamodel.EntityType;

public class UpdateDB {
    private static final SessionFactory ourSessionFactory;

    static {
        try {
            Configuration configuration = new Configuration();
            configuration.configure();

            ourSessionFactory = configuration.buildSessionFactory();
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static Session getSession() throws HibernateException {
        return ourSessionFactory.openSession();
    }

    public static void main(final String[] args) throws Exception {
        final Session session = getSession();
        try {
            System.out.println("querying all the managed entities...");
            final Metamodel metamodel = session.getSessionFactory().getMetamodel();
            for (EntityType<?> entityType : metamodel.getEntities()) {
                final String entityName = entityType.getName();
                final Query query = session.createQuery("from " + entityName);
                System.out.println("executing: " + query.getQueryString());
                /*if (query==null)continue;
                for (Object o : query.list()) {
                    if (o!=null){
                        System.out.println(o+ " ");
                    }
                }*/
            }
        } finally {
            session.close();
        }
    }
}

UserInfo 代码如下:
Hibernate提供了很多的注入的标签,可以参考这个链接 Hibernate4注解方法(全)
可以对应下面通过Hibernate生成的数据库表的截图进行对比你就能很快找到规则


package com.Lipt0n.test.POJO;

import lombok.Data;
import org.hibernate.annotations.Table;

import javax.persistence.*;
import java.util.Date;

@Data
@Entity
@Table(appliesTo = "UserInfo", comment = "用户信息表") 
public class UserInfo {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(columnDefinition="varchar(20) COMMENT '用户id'")
    private String userId;

    @Column(columnDefinition="varchar(20) COMMENT '用户名'")
    private String username;

    @Column(columnDefinition="int COMMENT '性别'")
    private boolean sex;

    @Column(columnDefinition="varchar(50) COMMENT '密码'")
    private String password;

    @Column(columnDefinition="timestamp default CURRENT_TIMESTAMP COMMENT '创建账号日期'")
    private Date createDate;

    @Column(columnDefinition="int COMMENT '部门id'")//关联DeptInfo表
    private int deptId;

    @Column(columnDefinition="varchar(50) COMMENT '邮箱地址'")
    private String email;

    @Column(columnDefinition="varchar(20) COMMENT '手机号码'")
    private int phoneNumber;

    @Column(columnDefinition="date COMMENT '出身年月'")
    private Date birthday;

    @Column(columnDefinition="int COMMENT '角色id'")
    private int roleId;

    @Column(columnDefinition="varchar(100) COMMENT '头像地址'")
    private String headImgUrl;

    @Column(columnDefinition="int COMMENT '账号状态码'")
    private int stateCode;

    @Column(columnDefinition = "decimal COMMENT '直属领导id'")
    private long leaderId;

    @Column(columnDefinition = "decimal COMMENT '更新人id'")
    private long lastUpdater;

    @Column(columnDefinition = "timestamp default CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '最后更新时间'")
    private Date updateDate;

    @Column(columnDefinition="varchar(20) COMMENT '职位id'")
    private int titleId;

}

image.png

做好了上面的准备后,点击上图红圈的执行选项后,如果你的数据库没有配置错,查看控制台输出的信息


image.png

刷新一下你的数据库管理工具,会发现多了张UserInfo的表说明已经成功用Hibernate框架进行了映射


image.png

数据库表已经建好了,关于Hibernate的东西暂时说到这,回到SSM的部分

mybatis

表已经建好了,接下来要实现mybatis对表进行增删改查

前面说过了有三个xml配置文件:

  1. applicationContext.xml (全局生效)
  2. applicationContext-myibatis.xml(全局生效)
  3. dispatcher-servlet.xml(非全局只对Spring生效)

为什么这里要把Spring相关配置写在applicationContext.xml而不是dispatcher-servlet.xml,应该是因为配置Spring日志和数据库需要全局生效?不确定如有错误欢迎指出.

先要配置applicationContext.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:task="http://www.springframework.org/schema/task"
       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/task http://www.springframework.org/schema/task/spring-task.xsd">


    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath*:jdbc.properties</value>  <!--指向数据库的配置文件-->
                <value>classpath*:log4j.properties</value> <!--指向log4j框架的配置文件-->
            </list>
        </property>
    </bean>

applicationContext-myibatis.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:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">


    <context:annotation-config/>
<!--
    当有多个全局配置文件的时候,有可能会出现重复扫描导致出错
    这里的 <context:component-scan base-package="com.tronrun.exhibition">
    指定了要扫描的包名但是下面的
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    指定排除扫描所有加了@Controller注解的类 (排除 排除 排除)
    -->
    <context:component-scan base-package="com.Lipt0n.test">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>


   <!--配置mybatis连接数据库的参数-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${database.driver}" />
        <property name="url" value="${database.url}" />
        <property name="username" value="${database.username}" />
        <property name="password" value="${database.password}" />
        <!--连接池的最大数据库连接数 -->
        <property name="maxActive" value="${database.maxActive}" />
        <!--最大等待连接中的数量 -->
        <property name="maxIdle" value="${database.maxIdle}" />
        <!--最大等待毫秒数 -->
        <property name="maxWait" value="${database.maxWait}" />
        <property name="defaultAutoCommit" value="true"/>
    </bean>



    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSession FactoryBean">
        <!--引用数据库bean对象-->
        <property name="dataSource" ref="dataSource" />
        <!--引用MyBatis的配置文件的文件路径 
        注意路径是否对,否者运行出错很难发现问题,切记-->
        <property name="configLocation" value="WEB-INF/sqlMapConfig.xml" />
        <!--Mapper所在的文件路径(这里的*.xml表示所有.xml结尾的文件) 
        注意路径是否对,否者运行出错很难发现问题,切记-->
         <!--Mapper文件的路径
         注意路径是否对,否者运行出错很难发现问题,切记-->
        <property name="mapperLocations" value="classpath*:com/Lipt0n/test/Mapper/*.xml" />
    </bean>


      <!--Mapper扫描配置-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--basePackage扫描的路径
          注意路径是否对,否者运行出错很难发现问题,切记-->
        <property name="basePackage" value="com.Lipt0n.test.Mapper"></property>
         <!--传入sqlSessionFactoryBeanName对象,指向的是上面配置的sqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
          <!--对注入标签@Repository生效-->
        <property name="annotationClass" value="org.springframework.stereotype.Repository"></property>
    </bean>
</beans>

dispatcher-servlet.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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

<!-- 使用注解驱动 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <!--封装好的适配器,把null的数据转成空字符-->
                    <bean class="com.Lipt0n.test.Tools.JsonObjectMapper">
                        <!-- 处理responseBody 里面日期类型 -->
                        <property name="dateFormat">
                            <bean class="java.text.SimpleDateFormat">
                                <constructor-arg type="java.lang.String" value="yyyy-MM-dd HH:mm:ss" />
                            </bean>
                        </property>
                    </bean>

                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>




    <!-- 定义扫描装载控制器的包路径,排除用了@Service标签的类 -->
    <context:component-scan base-package="com.Lipt0n.test">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
    </context:component-scan>


    <!-- 定义视图解析器,找到Web工程/WEB-INF/JSP文件夹,且文件结尾为jsp的文件作为映射 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="jsonConverter"></ref>
            </list>
        </property>
    </bean>

    <!--配置MappingJackson2HttpMessageConverter的编码方式防止中文乱码-->
    <bean id="jsonConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
        <property name="supportedMediaTypes">
            <list>
                <value>application/json;charset=UTF-8</value>
            </list>
        </property>
    </bean>

</beans>

mybatis 三个主要的配置文件设置好了,剩下就是怎么样调用:
调用简单理解分为三个步骤:
1.在Controller通过@Autowired注入得到Service的实例化对象
2.在Controller调用Service(业务层)封装好业务方法
3.调用Service的方法时,在Service调用了DAO(持久层)执行添删改查的操作,得到结果后进行判断后返回最终的结果 [在这里DAO层就是Mapper,下面马上会讲到]

下面从里到外贴出代码和重点,先看一眼Controller、Service、Mapper的目录结构


image.png
Mapper(持久层):

从目录结果可以看到Mapper目录下有两个文件分包是 xxxxMapper 和xxxxMapper.xml
首先xxxxMapper是一个接口也是DAO层(数据访问层),我们需要在这个接口里面定义需要的方法,例如添删改查

package com.Lipt0n.test.Mapper;

import com.Lipt0n.test.Beans.*;
import org.springframework.stereotype.Repository;
//代表这个类是DAO层
@Repository

public interface UserInfoMapper {

    int insertUser(UserData userData);

Mapper.xml 在默认的生成模板不存在,我们可以先手动创建模板方便日后使用:


image.png

粘贴代码到右边的输入框

<?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>
image.png

以后再需要新建XXXMapper.xml就能快速进行创建了,下面给出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" >
<!--可以看到这里的namespace指向的类名跟这个xml文件的名字是一模一样的都是UserInfoMapper-->
<mapper namespace="com.Lipt0n.test.Mapper.UserInfoMapper">

    <insert id="insertUser" parameterType="com.Lipt0n.test.Beans.UserData">
        insert into Lipt0n.UserInfo (
        userId,password,username,phoneNumber,roleId,deptId)
        values (#{userId},#{password},#{username},#{phoneNumber},#{roleId},#{deptId})
    </insert>

</mapper>

关于Mapper.xml的编写规则其实和sql差不多

package com.Lipt0n.test.Mapper;

import com.Lipt0n.test.Beans.*;
import org.springframework.stereotype.Repository;

@Repository

 
public interface UserInfoMapper {

    int insertUser(UserData userData);




}

[注意Mapper 元素中的namespace属性,它要和一个接口的全限定名保持一致 ,而里面的 SQL的id也需要和接口定义的方法完全保持一致,定义 mybatis映射文件或许读者会有一个很大的疑问,就是是否需要定义一个实现类呢?答案是不需要]---Java EE互联网轻量级框架整合开发

Service(业务层):

在Service分两个类一个是接口类,一个是实现类代码分别如下:

接口类如下:
package com.Lipt0n.test.Service;



import com.Lipt0n.test.Beans.UserData;

public interface UserInfoService {



    int insertUser(UserData userData);


}

实现类如下:

package com.Lipt0n.test.Service.Impl;

import com.Lipt0n.test.Beans.*;
import com.Lipt0n.test.Mapper.UserInfoMapper;
import com.Lipt0n.test.Service.UserInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;


@Service
//@Component
public class UserInfoServiceImpl implements UserInfoService {


    @Autowired
    private UserInfoMapper userInfoMapper;


    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public int insertUser(UserData userData) {
        return userInfoMapper.insertUser(userData);
    }


}

关于持久层和业务层,的具体作用可以参考这篇博客

Controller:
上面的准备工作做好,剩下的就简单了,就是调用Service(业务层)封装好的业务方法,具体代码如下:

  package com.Lipt0n.test.Controller;

import com.Lipt0n.test.Beans.*;
import com.Lipt0n.test.Service.UserInfoService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

//这个标签是@Controller+@ ResponseBody结合体
@RestController
public class UserInfoController {


    @Autowired
    private UserInfoService userInfoService = null;



    /*
    * @RequestMapping 用来处理请求地址映射的注解
    * value 指定请求的实际地址
    * method 指定请求的method类型 如GET POST PUT等;
    * */
    @RequestMapping(value = "/insertUser",method = RequestMethod.GET)
    //新增用户信息
    public ResultBean InsertUser(UserData userData) {
        ResultBean resultBean = new ResultBean();
        int code = userInfoService.insertUser(userData);
        resultBean.setCode(-1);
        resultBean.setMsg("新增用户失败");
        if (code==1){
            resultBean.setCode(0);
            resultBean.setMsg("新增用户成功");

        }
        return resultBean;
    }
}

//还记得前面的我们在dispatcher-servlet.xml中配置了MappingJackson2HttpMessageConverter?它的作用就是把后台返回的Java对象转换为Json字符串传递到前台

后台返回的数据最好有一个固定的Bean类方便调试和解析数据分为三个变量分别是code、msg、result:
code:接口根据查询得到的结果返回状态码
msg:接口查询后的结果进行描述方便
result:这是一个object对象,根据前面配置好的MappingJackson2HttpMessageConverter会自动将object对象转换成json返回

package com.Lipt0n.test.Beans;

public class ResultBean {

    private int code;
    private String msg;
    private Object result;


    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getResult() {
        return result;
    }

    public void setResult(Object result) {
        this.result = result;
    }
}

完成上面的操作重新部署运行项目,在浏览器输入:http://localhost:8080/Lipt0n/insertUser?username=test

image.png

如果你在浏览器看到下面的内容说明你已经成功,如果有报错可以在下面留言,上面例子的代码会上传到github有些需要的可以上去下载完整的代码 : )

以上就是主要的内容了,还有事务日志和拦截内容没写,东西太多了写不下去了如果多人看这篇文章再更新~

: )