SSM demo

最新推荐文章于 2022-11-11 19:27:41 发布

qq_39479976

最新推荐文章于 2022-11-11 19:27:41 发布

阅读量520

点赞数 1

文章标签： ssm

本文链接：https://blog.csdn.net/qq_39479976/article/details/119137777

版权

一.创建maven工程

1.file-new-project-Maven，按照图中的选择,next

2.填写工程名称，并选择工程存放地址，如图工程名为study02,存于F:\code\study\study02中
在这里插入图片描述
3.maven的配置，如下图一所示可是使用默认地址的maven，也可以配置本地的maven路径，如图二所示。User settings file是选择本地maven安装路径中的settings.xml的路径，local repository配置的是maven仓库的路径，即通过maven 依赖下载的包所存放的位置。
在这里插入图片描述

需要说明的是，由于maven的settings.xml配置文件没有配置镜像，可能会导致在依赖下载失败，可以在修改settings.xml中的镜像地址，加入阿里云的镜像地址

  <mirrors>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
     -->
   <!-- <mirror>
      <id>maven-default-http-blocker</id>
      <mirrorOf>external:http:*</mirrorOf>
      <name>Pseudo repository to mirror external repositories initially using HTTP.</name>
      <url>http://0.0.0.0/</url>
      <blocked>true</blocked>
    </mirror> -->
<mirror>
  <id>alimaven</id>
  <name>aliyun maven</name>
  <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
  <mirrorOf>central</mirrorOf>        
</mirror>
  </mirrors>

4.点击finish，IDEA将创建该maven工程，如出现以下状态，则代表创建成功
在这里插入图片描述
5.创建后的工程目录如下所示

在该目录中，需要在src/main下新建两个文件夹，分别是java和test，并在project structure的Modules中j将java文件目录标记为Sources,将test文件目录标记为Test，将resources标记为Resources。选择java目录，点击Mark as: Sources即可将java目录标记为源目录，放的是Java源码，Test放的是测试的源码，Resources放的是资源文件，Test Resources放的是测试使用的资源文件，Excluded是排除项（比如编译后的trarget目录）
在这里插入图片描述
完整的目录结构如下所示，这样做只是根据习惯，为了能让工程更加的清晰，方便。

二. 引入依赖

在pom.xml中配置依赖，在中写入需要引入的依赖，maven会根据依赖自动下载包，若工程未及时引入依赖，可以点击右上角的maven刷新。

<?xml version="1.0" encoding="UTF-8"?>
<!-- $Id: pom.xml 642118 2008-03-28 08:04:16Z reinhard $ -->
<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/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <packaging>war</packaging>

  <name>study01</name>
  <groupId>org.example</groupId>
  <artifactId>study01</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <spring.version>5.0.3.RELEASE</spring.version>
    <mybatis.version>3.4.4</mybatis.version>
  </properties>

  <build>
    <plugins>
      <plugin>
        <groupId>org.mortbay.jetty</groupId>
        <artifactId>maven-jetty-plugin</artifactId>
        <version>6.1.7</version>
        <configuration>
          <connectors>
            <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
              <port>8888</port>
              <maxIdleTime>30000</maxIdleTime>
            </connector>
          </connectors>
          <webAppSourceDirectory>${project.build.directory}/${pom.artifactId}-${pom.version}</webAppSourceDirectory>
          <contextPath>/</contextPath>
        </configuration>
      </plugin>
    </plugins>
  </build>

  <dependencies>
    <!-- 单元测试 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <!-- 第一部分：Spring 配置-->
    <!-- Spring core -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</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-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- Spring DAO -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- Spring mvc -->
    <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>
    <!-- 第二部分：Servlet web -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>1.1.2</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.4</version>
    </dependency>
    <!-- 第三部分：数据库和mybatis -->
    <!-- 数据库 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>
    <!-- 数据库连接池 -->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.2</version>
    </dependency>
    <!-- MyBatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <!-- mybatis-spring整合包 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>
    <!-- 第四部分：日志 -->
    <!-- 实现slf4j接口并整合 -->

    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.1.1</version>
    </dependency>

    <!--导入日志依赖包-->
    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.16</version>
    </dependency>
    <!-- 引入json的依赖包-->
    <dependency>
      <groupId>net.sf.json-lib</groupId>
      <artifactId>json-lib</artifactId>
      <version>2.4</version>
      <classifier>jdk15</classifier>
    </dependency>
    <dependency>
      <groupId>commons-beanutils</groupId>
      <artifactId>commons-beanutils</artifactId>
      <version>1.7.0</version>
    </dependency>
    <dependency>
      <groupId>commons-collections</groupId>
      <artifactId>commons-collections</artifactId>
      <version>3.1</version>
    </dependency>
    <dependency>
      <groupId>commons-lang</groupId>
      <artifactId>commons-lang</artifactId>
      <version>2.5</version>
    </dependency>
    <dependency>
      <groupId>net.sf.ezmorph</groupId>
      <artifactId>ezmorph</artifactId>
      <version>1.0.3</version>
    </dependency>
  </dependencies>
</project>

3.配置文件

3.1 配置web.xml文件

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1" metadata-complete="true">
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置springMVC需要加载的配置文件
        spring-dao.xml,spring-service.xml,spring-mvc.xml
        Mybatis - > spring -> springmvc
     -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring/spring-*.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <!-- 默认匹配所有的请求 -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>
      org.springframework.web.filter.CharacterEncodingFilter
    </filter-class>
    <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>
</web-app>

3.2 配置spring-dao.xml，spring-service.xml，spring-mvc,xml，这三个配置文件放于resource-spring文件夹下。
3.2.1 spring-mvc.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:mvc="http://www.springframework.org/schema/mvc"
       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/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
    <!-- 配置SpringMVC -->
    <!-- 1.开启SpringMVC注解模式 -->
    <!-- 简化配置：
        (1)自动注册DefaultAnootationHandlerMapping,AnotationMethodHandlerAdapter
        (2)提供一些列：数据绑定，数字和日期的format @NumberFormat, @DateTimeFormat, xml,json默认读写支持
    -->
    <mvc:annotation-driven/>

    <!-- 2.静态资源默认servlet配置
        (1)加入对静态资源的处理：js,gif,png
        (2)允许使用"/"做整体映射
     -->
    <mvc:default-servlet-handler/>

    <!-- 3.配置jsp 显示ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 4.扫描web相关的bean -->
    <!--<context:component-scan base-package="com"/>-->
    <context:component-scan base-package="com.controller"/>
</beans>

3.2.2 spring-service.xml 配置service层

<?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"
       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">
    <!-- 扫描service包下所有使用注解的类型 -->
    <context:component-scan base-package="com.service"/>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 配置基于注解的声明式事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

3.2.3 配置spring-dao.xml层：配置与数据库的连接等，除此以外涉及到mybatis的配置文件，以及数据库的配置jdbc.properties

<?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
    http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置整合mybatis过程 -->
    <!-- 1.配置数据库相关参数properties的属性：${url} -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 2.数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 配置连接池属性 -->
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

        <!-- c3p0连接池的私有属性 -->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!-- 关闭连接后不自动commit -->
        <property name="autoCommitOnClose" value="false"/>
        <!-- 获取连接超时时间 -->
        <property name="checkoutTimeout" value="10000"/>
        <!-- 当获取连接失败重试次数 -->
        <property name="acquireRetryAttempts" value="30"/>

        <property name="preferredTestQuery" value="SELECT 1"/>
        <property name="idleConnectionTestPeriod" value="18000"/>
        <property name="testConnectionOnCheckout" value="true"/>

    </bean>

    <!-- 3.配置SqlSessionFactory对象 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置MyBaties全局配置文件:mybatis-config.xml -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!-- 扫描pojo包 使用别名 -->
        <property name="typeAliasesPackage" value="com.pojo"/>
        <!-- 扫描sql配置文件:mapper需要的xml文件 -->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

    <!-- 4.配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- 给出需要扫描Dao接口包 -->
        <property name="basePackage" value="com.dao"/>
    </bean>
    <context:annotation-config></context:annotation-config>
</beans>

mybatis-config.xml,用于配置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>
    <!-- 配置全局属性 -->
    <settings>
        <!-- 使用jdbc的getGeneratedKeys获取数据库自增主键值 -->
        <setting name="useGeneratedKeys" value="true"/>

        <!-- 使用列别名替换列名 默认:true -->
        <setting name="useColumnLabel" value="true"/>

        <!-- 开启驼峰命名转换:Table{create_time} -> Entity{createTime} -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>

        <!-- 设置MyBatis的一级缓存为STATEMENT级别，在查询时，会清空缓存 还可以在select语句查询后添加flushCache="true" 实现同样的功能-->
        <!-- MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。
	  		 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。
	   		 若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。-->
        <setting name="localCacheScope" value="STATEMENT"/>
    </settings>
</configuration>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/student?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false
jdbc.username=root
jdbc.password=123456
#定义初始连接数
initialSize=0
#定义最大连接数
maxActive=20
#定义最大空闲
maxIdle=20
#定义最小空闲
minIdle=1
#定义最长等待时间
maxWait=60000
maxReconnects=3

在配置完全部配置文件后，工程的目录为：
在这里插入图片描述

4.代码

4.1 pojo包内，创建ClassInfo类，记录班级的属性，命名最好与数据库中班级信息表中的字段对应，命名方式参照驼峰命名的方式

package com.pojo;

public class ClassInfo {
    private int id;
    private String className;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public ClassInfo(int id, String className) {
        this.id = id;
        this.className = className;
    }

    public ClassInfo() {
    }
}

4.2 dao层包括接口以及与之对应的mapper
在com.dao包下创建ClassInfoDao接口

package com.dao;

import com.pojo.ClassInfo;

public interface ClassInfoDao {
    //插入班级名称
    void insertClassInfo(ClassInfo classInfo);

    //查询班级名称
    ClassInfo getClassInfo(int id);

    //删除班级
    void deleteClassInfo(int id);

    //编辑班级信息
    void updateClassInfo(String className);
}

在ClassInfoMapper.xml中实现上述接口中的全部方法，该文件位于resource/mapper下

<?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命名空间，为了对sql语句进行隔离，方便管理，mapper开发dao方式，使用namespace有特殊作用  
mapper代理开发时将namespace指定为mapper接口的全限定名  
 -->
<mapper namespace="com.dao.ClassInfoDao">
    <!--在mapper.xml文件中配置很多的sql语句，执行每个sql语句时，封装为MappedStatement对象
    mapper.xml以statement为单位管理sql语句
     -->

 <insert id="insertClassInfo" parameterType="com.pojo.ClassInfo">
     insert into classInfo (id,className) values (#{id},#{className});
 </insert>

 <select id="getClassInfo" resultType="com.pojo.ClassInfo">
     select * from classInfo where id=#{id};
 </select>

 <delete id="deleteClassInfo" parameterType="int">
     delete from student where id=#{id};
 </delete>

 <update id="updateClassInfo"  parameterType="String">
     update student set className=#{className};
 </update>

</mapper>

4.3 service 业务逻辑层
在com.service包下创建ClassInfoService.java，需要注意，该类属于service层，在使用时需要给其加上注解，即@Service,，当需注入dao层的bean时，只需要使用@Resource和@Autowide其中,@Autowired与@Resource都可以用来装配bean. 都可以写在字段上,或写在setter方法上。
@Autowired默认按类型装配（这个注解是属业spring的），默认情况下必须要求依赖对象必须存在，如果要允许null值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用，如下：

@Autowired () @Qualifier ( "baseDao" )
private BaseDao baseDao;

@Resource（这个注解属于J2EE的），默认按照名称进行装配，名称可以通过name属性进行指定，如果没有指定name属性，当注解写在字段上时，默认取字段名进行安装名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

@Resource (name= "baseDao" )
private BaseDao baseDao;

推荐使用：@Resource注解在字段上，这样就不用写setter方法了，并且这个注解是属于J2EE的，减少了与spring的耦合。这样代码看起就比较优雅

package com.service;
import com.constanst.ErrorMsg;
import com.dao.ClassInfoDao;
import com.pojo.AddClassInfoReq;
import com.pojo.AddClassInfoRsp;
import com.pojo.ClassInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;

@Service
@Transactional
public class ClassInfoService {
    @Resource
    ClassInfoDao classInfoDao;
    /*保存业务逻辑错误信息字段*/
    private String errMessage;
    private int errCode;

    public String getErrMessage() {
        return this.errMessage;
    }

    public int getErrCde() {
        return this.errCode;
    }

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void insertClassInfo(ClassInfo req) throws Exception {
        classInfoDao.insertClassInfo(req);
        this.errCode = ErrorMsg.ERR_CODE_SUCCESS;
        this.errMessage = ErrorMsg.ERR_MSG_SUCCESS;
    }

    public ClassInfo getClassInfo(int id) throws Exception {
        return classInfoDao.getClassInfo(id);
    }
}

4.4 controller层
创建ClassInfoController

package com.controller;

import com.constanst.ErrorMsg;
import com.pojo.AddClassInfoReq;
import com.pojo.AddClassInfoRsp;
import com.pojo.ClassInfo;
import com.service.ClassInfoService;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;

@Controller
@RequestMapping("/Class")
public class ClassInfoController {
    private static final Logger LOGGER = Logger.getLogger(ClassInfoController.class);

    @Resource
    ClassInfoService classInfoService;


    @ResponseBody
    @RequestMapping(value = "/add", method = RequestMethod.POST)
    //RequestBody将传输过来的对象映射为Java对象，要求字段名需要一致 不然会映射失败
    public AddClassInfoRsp insertClassInfo(@RequestBody ClassInfo req) throws Exception {
    AddClassInfoRsp rsp=new AddClassInfoRsp(ErrorMsg.ERR_CODE_SYSTEM,ErrorMsg.ERR_MSG_SYSTEM);
    classInfoService.insertClassInfo(req);
    rsp.setErrCode(classInfoService.getErrCde());
    rsp.setErrDesc(classInfoService.getErrMessage());
    return rsp;
    }

    @ResponseBody
    @RequestMapping(value = "/get", method = RequestMethod.POST)
    //RequestBody将传输过来的对象映射为Java对象，要求字段名需要一致 不然会映射失败
    public ClassInfo getClassInfo(int id) throws Exception {
        return classInfoService.getClassInfo(id);
    }
}

至此，一个最简单的demo就完成了，接下来需要对该接口进行测试

测试

测试工具：postman
打开postman，并在URL中输入http://localhost:8080/student/Class/add，同时选择post的方式，选择row-json的数据格式，并输入以下字段（与Controller中的输入对象保持一致
{
“id”:7,
“className”:“0001”
}
得到的返回结果是
{
“errCode”: 0,
“errDesc”: “”
}
表示请求成功，该接口测试通过
在这里插入图片描述

qq_39479976

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
SSM demo

一.创建maven工程1.file-new-project-Maven，按照图中的选择,next2.填写工程名称，并选择工程存放地址，如图工程名为study02,存于F:\code\study\study02中3.maven的配置，如下图一所示可是使用默认地址的maven，也可以配置本地的maven路径，如图二所示。User settings file是选择本地maven安装路径中的settings.xml的路径，local repository配置的是maven仓库的路径，即通过maven 依赖
复制链接

扫一扫