基于Spring4.x的SSM框架搭建以及Spring和SpringMVC、Mybatis介绍

最新推荐文章于 2022-05-08 15:48:36 发布

一个坏小孩

最新推荐文章于 2022-05-08 15:48:36 发布

阅读量332

点赞数

分类专栏： SpringMVC框架 SSM 文章标签： java spring

本文链接：https://blog.csdn.net/qq_37215474/article/details/105372515

版权

SpringMVC框架同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

SSM

1 篇文章 0 订阅

订阅专栏

Spring已经到Spring5.x，为什么还要做Spring4的整合，这里仅仅是为了避免以后遇到类似问题可以少踩一些坑，不至于在框架搭建时浪费时间。

写在最前面

JavaEE体系结构包括四层，从上到下分别是应用层、Web层、业务层、持久层。Struts和SpringMVC是Web层的框架，Spring是业务层的框架，Hibernate和MyBatis是持久层的框架。

1、Spring
Spring是一个开源容器框架，可以接管web层，业务层，dao层，持久层的组件，并且可以配置各种bean,和维护bean与bean之间的关系。其核心就是控制反转(IOC),和面向切面(AOP),简单的说就是一个分层的轻量级开源框架。
2、SpringMVC
Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。SpringMVC是一种web层mvc框架，用于替代servlet（处理|响应请求，获取表单参数，表单校验等。SpringMVC是一个MVC的开源框架，SpringMVC=struts2+spring，springMVC就相当于是Struts2加上Spring的整合。
3、SpringBoot（顺便提一下）

Springboot是一个微服务框架，延续了spring框架的核心思想IOC和AOP，简化了应用的开发和部署。Spring Boot是为了简化Spring应用的创建、运行、调试、部署等而出现的，使用它可以做到专注于Spring应用的开发，而无需过多关注XML的配置。提供了一堆依赖打包，并已经按照使用习惯解决了依赖问题—>习惯大于约定。

4、为什么要使用SpringMVC
很多应用程序的问题在于处理业务数据的对象和显示业务数据的视图之间存在紧密耦合，通常，更新业务对象的命令都是从视图本身发起的，使视图对任何业务对象更改都有高度敏感性。而且，当多个视图依赖于同一个业务对象时是没有灵活性的。

SpringMVC是一种基于Java，实现了Web MVC设计模式，请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将Web层进行职责解耦。基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，SpringMVC也是要简化我们日常Web开发。

5、流程图
在这里插入图片描述 6、持久层技术解决方案
7、MyBatis对传统JDBC的改进

1、数据库连接，使用时就创建，不使用时立即释放，对数据库进行频繁连接开始和关闭，造成数据库资源浪费，影响数据库的性能

设想：使用数据库连接池管理数据库连接

2、将sql语句硬编码到java代码中，如果sql语句修改，需要重新编译java代码，不利于系统维护

设想：将sql语句配置到xml配置文件中，即使sql语句变化，也不需要对java代码进行重新编译

3、向preparedstatement中设置参数，对占位符位置和设置参数值，硬编码在java代码中，不利于系统维护。

设想：将sql语句及占位符和参数全部配置到xml中。

4、从resultSet中遍历结果集数据时，存在硬编码，将获取表的字段进行硬编码，不利于系统维护

设想：将查询结果集，自动映射成java对象

于是，MyBatis如何解决JDBC的问题~

1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

解决：在SqlMapConfig.xml中配置数据链接池，使用连接池管理数据库链接。

2、Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。

解决：将Sql语句配置在XXXXmapper.xml文件中与java代码分离。

3、向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。

解决：Mybatis自动将java对象映射至sql语句，通过statement中的parameterType定义输入参数的类型。

4、对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。

解决：Mybatis自动将sql执行结果映射至java对象，通过statement中的resultType定义输出结果的类型。
MyBatis则简化了传统JDBC方法，解决了：①频繁链接和释放数据库的浪费、②SQL语句与代码的高耦合、③参数传递麻烦、④结果解析麻烦。

一、工程结构图—请忽略common包下的类

在这里插入图片描述

二、项目使用的POM文件配置

<?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.wang</groupId>
    <artifactId>SpringDemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!--版本控制-->
        <spring.version>4.3.8.RELEASE</spring.version>
        <commons-fileupload.version>1.3.1</commons-fileupload.version>
    </properties>

    <dependencies>

        <!-- Spring核心依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

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

        <!--Spring Web依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--SpringMVC 依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--Spring对JDBC的支持-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--Spring事务依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--MySQL依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.6</version>
        </dependency>

        <!--FastDFS依赖-->
        <dependency>
            <groupId>org.csource.fastdfs</groupId>
            <artifactId>fastdfs</artifactId>
            <version>1.2</version>
        </dependency>
        <!--文件上传-->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>${commons-fileupload.version}</version>
        </dependency>

        <!--测试依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!--日志依赖-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.2</version>
        </dependency>
        <!--FastJson工具包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.36</version>
        </dependency>
        <!--Lombok小插件-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.12</version>
            <scope>provided</scope>
        </dependency>
        <!--mybatis依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>
        <!-- mybatis/spring包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!--分页插件依赖-->
        <!--5.x会出现版本过高冲突导致SQLSession无法创建-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>4.0.0</version>
        </dependency>
        <!--阿里数据库连接池-->
        <!--1.0.x会出现版本过低冲突 数据库连接异常-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.8</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!--Maven编译插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                    <showWarnings>true</showWarnings>
                </configuration>
            </plugin>
            <!--Tomcat插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8080</port>
                    <path>/</path>
                    <uriEncoding>UTF-8</uriEncoding>
                    <server>tomcat7</server>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

三、web.xml的配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="WebApp_ID" version="3.0">

    <!--SpringMVC核心配置-->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:application-mvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--通过Spring的ContextLoadListener来监听Web容器的生命周期-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!--初始化配置文件，加载Spring的配置文件-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:application-spring.xml</param-value>
    </context-param>

    <!--配置字符集编码-->
    <filter>
        <filter-name>CharacterEncodingFilter</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>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--初始化显示页面-->
    <welcome-file-list>
        <welcome-file>/WEB-INF/jsp/index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

四、applicationContext-mvc.xml的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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-3.2.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.2.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
    
    <!--开启注解支持-->
    <context:annotation-config/>
    <!--启用注解驱动，主要负责和前端页面参数的绑定-->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
                <property name="supportedMediaTypes" value="application/json"/>
                <property name="features">
                    <array>
                        <value>WriteMapNullValue</value>
                        <value>WriteDateUseDateFormat</value>
                    </array>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
    <!--释放静态资源-->
    <mvc:default-servlet-handler/>
    <!-- 静态资源映射 -->
    <mvc:resources mapping="/static/**" location="/WEB-INF/static/"/>

    <!-- 配置多媒体解析器 -->
    <bean id="multipartResolver"
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="defaultEncoding" value="UTF-8"></property>
        <!-- 设定文件上传的最大值 5MB，5*1024*1024 -->
        <property name="maxUploadSize" value="5242880"></property>
    </bean>

    <!--配置视图解析器-->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          p:prefix="/WEB-INF/jsp/" p:suffix=".jsp"/>
    <!--扫描Controller，建议SpringMVC的配置文件只扫描controller-->
    <context:component-scan base-package="com.wang.controller"/>

</beans>

五、applicationContext-spring.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">

    <!--开启注解支持-->
    <context:annotation-config/>
    <!--开启注解扫描-->
    <context:component-scan base-package="com.wang.service.*"/>
    <!--开启声明式事务-->
    <!--<tx:annotation-driven/>-->
    <!--配置数据源-->
    <!--引入外部资源部-->
    <context:property-placeholder location="classpath*:*.properties"/>
    <!-- druid 数据库连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!-- 数据库基本信息配置 -->
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="url" value="${jdbc.url}"/>
    </bean>
    <!--使用spring帮助创建sqlSession -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--关联数据源-->
        <property name="dataSource" ref="dataSource"></property>
        <property name="typeAliasesPackage" value="com.wang.user"/>
        <!-- 加载mybatis的全局配置文件 -->
        <property name="configLocation" value="classpath:SqlMapConfig.xml"/>
    </bean>
    <!--配置 扫描器，扫描接口，并创建接口对象 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.wang.dao"/>
    </bean>
    <!--spring+hibernate 事务配置-->
    <!-- 事务管理器配置,单数据源事务 -->
    <!-- <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
         <property name="sessionFactory" ref="sessionFactory" />
     </bean>-->
    <!-- 使用annotation定义事务 -->
    <!--<tx:annotation-driven  transaction-manager="transactionManager"   proxy-target-class="true" />-->

    <!--定义Mybatis事务管理器-->
    <!--这里说明一下，有的把这个注解放在类名称上面了，这样你配置的这个@Transactional 对这个类中的所有public方法都起作用-->
    <bean id="DataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--关联数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--使用AOP管理事务管理器开启事务-->
    <tx:advice id="TxAdvice" transaction-manager="DataSourceTransactionManager">
        <!--配置事物的隔离级别-->
        <tx:attributes>
            <!--PROPAGATION_REQUIRED：如果存在一个事务，则支持当前事务。如果没有事务则开启-->
            <!--PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务。如果没有事务则开启-->
            <!--PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行-->
            <!--PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。-->
            <!--PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。-->
            <!--PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务。-->
            <!--PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常-->
            <!--PROPAGATION_NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务,
            则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行-->
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="get*" read-only="true"/>
            <!--只有在方法中抛出运行时Exception时才会回滚-->
            <!--默认情况下当发生RuntimeException的情况下，事务才会回滚，所以要注意一下
            如果你在程序发生错误的情况下，有自己的异常处理机制定义自己的Exception，必须从RuntimeException类继承 这样事务才会回滚！-->
            <tx:method name="*" no-rollback-for="Exception"/>
        </tx:attributes>
    </tx:advice>
    <!--配置事务的切入点-->
    <aop:config>
        <!--配置事务切点表达式-->
        <!--其中第一个*代表返回值，第二*代表service下子包，第三个*代表方法名，“（..）”代表方法参数。-->
        <aop:pointcut id="services" expression="execution(* com.wang.service.*.*(..))"/>
        <!--开启事务-->
        <aop:advisor advice-ref="TxAdvice" pointcut-ref="services"/>
    </aop:config>

</beans>

六、SqlMapConfig.xml的配置

<?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>
    <plugins>
        <!-- com.github.pagehelper为PageHelper类所在包名 -->
        <plugin interceptor="com.github.pagehelper.PageHelper">
            <property name="dialect" value="mysql"/>
            <!-- 该参数默认为false -->
            <!-- 设置为true时，会将RowBounds第一个参数offset当成pageNum页码使用 -->
            <!-- 和startPage中的pageNum效果一样-->
            <property name="offsetAsPageNum" value="true"/>
            <!-- 该参数默认为false -->
            <!-- 设置为true时，使用RowBounds分页会进行count查询 -->
            <property name="rowBoundsWithCount" value="true"/>
            <!-- 设置为true时，如果pageSize=0或者RowBounds.limit = 0就会查询出全部的结果 -->
            <!-- （相当于没有执行分页查询，但是返回结果仍然是Page类型）-->
            <property name="pageSizeZero" value="true"/>
            <!-- 3.3.0版本可用 - 分页参数合理化，默认false禁用 -->
            <!-- 启用合理化时，如果pageNum<1会查询第一页，如果pageNum>pages会查询最后一页 -->
            <!-- 禁用合理化时，如果pageNum<1或pageNum>pages会返回空数据 -->
            <property name="reasonable" value="true"/>
        </plugin>
    </plugins>
</configuration>

七、jdbc.properties文件的配置

#Driver
jdbc.driverClassName=com.mysql.cj.jdbc.Driver
#数据库链接，
jdbc.url=jdbc:mysql://192.168.110.184:3306/springboot?useUnicode=true&characterEncoding=UTF-8
#帐号
jdbc.username=root
#密码
jdbc.password=roots
#检测数据库链接是否有效，必须配置
jdbc.validationQuery=SELECT 'x'
#初始连接数
jdbc.initialSize=3
#最大连接池数量
jdbc.maxActive=10
#去掉，配置文件对应去掉
#jdbc.maxIdle=20
#配置0,当线程池数量不足，自动补充。
jdbc.minIdle=0
#获取链接超时时间为1分钟，单位为毫秒。
jdbc.maxWait=60000
#获取链接的时候，不校验是否可用，开启会有损性能。
jdbc.testOnBorrow=false
#归还链接到连接池的时候校验链接是否可用。
jdbc.testOnReturn=false
#此项配置为true即可，不影响性能，并且保证安全性。意义为：申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
jdbc.testWhileIdle=true
#1.Destroy线程会检测连接的间隔时间
#2.testWhileIdle的判断依据
jdbc.timeBetweenEvictionRunsMillis=60000
#一个链接生存的时间（之前的值：25200000，这个时间有点BT，这个结果不知道是怎么来的，换算后的结果是：25200000/1000/60/60 = 7个小时）
jdbc.minEvictableIdleTimeMillis=300000
#链接使用超过时间限制是否回收
jdbc.removeAbandoned=true
#超过时间限制时间（单位秒），目前为5分钟，如果有业务处理时间超过5分钟，可以适当调整。
jdbc.removeAbandonedTimeout=300
#链接回收的时候控制台打印信息，测试环境可以加上true，线上环境false。会影响性能。
jdbc.logAbandoned=false

八、log4j.properties配置

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

九、Controller的代码

package com.wang.controller;

import com.wang.common.FastDFSClient;
import com.wang.service.UserService;
import com.wang.user.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;


/**
 * @author:一个坏小孩
 * @data：2020/3/19 0019 周四
 */
@Controller
public class SpringController {


    private UserService userService;

    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    @Value("${FILE_SERVER_URL}")
    private String FILE_SERVER_URL;

    @RequestMapping("/hello")
    public String springDemo() {

        return "hello";
    }


    /**
     * 文件上传
     *
     * @param file 上传文件对象
     * @return 文件上传路径
     */
    @RequestMapping("/upload")
    @ResponseBody
    public String upload(MultipartFile file) {

        String URL = "上传失败";
        //获取文件路径
        String path = file.getOriginalFilename();
        //获取文件后缀名
        String extName = path.substring(path.lastIndexOf(".") + 1);
        try {
            //读取配置文件
            FastDFSClient client = new FastDFSClient("classpath:fdfs_client.conf");
            String filePath = client.uploadFile(file.getBytes(), extName);
            URL = FILE_SERVER_URL + filePath;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return URL;
    }


    @RequestMapping("/user")
    @ResponseBody
    public List<User> getUser() {

        return userService.getUser();
    }

    /**
     * 表单数据SpringMVC会自动解析封装成对象
     *
     * @param user
     * @return
     */
    @RequestMapping("/postUser")
    @ResponseBody
    public User postUser(User user) {
        return user;
    }

}

一个坏小孩

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
基于Spring4.x的SSM框架搭建以及Spring和SpringMVC、Mybatis介绍

Spring已经到Spring5.x，为什么还要做Spring4的整合，这里仅仅是为了避免以后遇到类似问题可以少踩一些坑，不至于在框架搭建时浪费时间。写在最前面JavaEE体系结构包括四层，从上到下分别是应用层、Web层、业务层、持久层。Struts和SpringMVC是Web层的框架，Spring是业务层的框架，Hibernate和MyBatis是持久层的框架。1、SpringSpr...
复制链接

扫一扫