基于SSM的校园二手交易网站，对于SSM的复盘。一些面试常用的问题。

最新推荐文章于 2024-01-20 14:57:00 发布

秀才大大

最新推荐文章于 2024-01-20 14:57:00 发布

阅读量399

点赞数

分类专栏： SSM框架原理文章标签：面试 java 前端 mybatis spring

本文链接：https://blog.csdn.net/xiucai5211314/article/details/122521374

版权

SSM框架原理专栏收录该内容

5 篇文章 0 订阅

订阅专栏

代码我没有放上来，有需要的可以关注我私信我要，免费的，这是在去年的时候做的一个课程设计，我简单实现了后台管理，跟前端页面展示，重写了前端页面。但是对于具体的订单模块没有实现，针对于一般的课程设计这些工作量还是可以的，可以拿过去自己重新完成一下没有实现的模块，对于刚学习完SSM 对于框架的整合是非常友好的。主要是有一些SSM的内容是我认为面试长问的。在这里也感谢王二，二哥的一些面试常用问题。

废话不多说上导航，有一部分问题是跟王二，二哥那边搞得，然后我通过一些实例解释了一下。

文章目录

一、对于数据库的分析
- 需要注意的知识点？
- - 什么是外键？
  - char 和 varchar 的区别是什么？
二、复盘spring spring mvc 相关内容

一、对于数据库的分析

分析一下每个表之间的联系，数据库表为什么要这样设计。

admin：最值得一提的是对于权限的管理，主键是id

user：再看user的值得一提就是对于status的设计，对于用户可以封禁

goods：货物表，引用了外边的货物类别，以及对应用户id，以及卖出的状态，开始的时间

catalog：类别表，主要能统计一个数量，以及通过这个数量能查询到何种内容。
comments：评论表：主要是要关联哪个用户发的，以及关系到哪个货物。以及创建的时间。

focus：既然是关注，那就肯定是有货物以及用户。

image：对于商品的存放，需要引用商品的id

notice：求助表，user_id,context

purse:钱包，所属用户，总钱数，充值和体现，以及对于我们而言的一个状态

reply：对于这个回复表，暂时不需要考虑。

需要注意的知识点？

什么是外键？

如果公共关键字在一个关系中是主关键字，那么这个公共关键字被称为另一个关系的外键。在上方我们频繁引用的user_id就是外键

char 和 varchar 的区别是什么？

char，固定长度类型，类比于char（10），无论最后，存入的是什么，他们剩下没占的也有位子，是空字节。

varchar（n）：可变长度，占用的是每个字节，再加上一个记录长度的字节的长度。

二、复盘spring spring mvc 相关内容

（一）项目导入的包

每个包的功能对应了spring核心

在基础里有一个这样的

在开始使用注解之前引入

原因如下，是为了搞定扫描的时候需要的包

在使用基于代理类的AOP实现，导入的包

实现Mysql相关内容时，用相应的包

基于xml方式的声明式事务

提供对AspectJ的支持

Mybatis的依赖包

与MySQL驱动的包

使用动态SQL的包

MyBatis与Spring整舍的中间包

数据源所需要的JAR包

spring MVC 需要的包

json 所需要的包

（二）配置文件

web.xml 里的内容

1. 创建spring的容器ApplicationContext

在Web项目中，ApplicationContext容器的实例化工作会交由
Web服务器来完成。Web服务器实例化ApplicationContext容器时，通常会使用基于
ContextLoaderListener实现的方式，此种方式只需要在web.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>

上边代码的工作内容是为了创建一个容器，在没有整合之前。我们一般在测试类用以下的方法，在我的校园二手交易网站中，我用了上述方法。

2. spring mvc 里边使用的前端过滤器

初始化加载配置文件

  <!-- 配置Spring MVC前端控制器 DispatcherServlet -->
  <servlet>
       <servlet-name>springmvc</servlet-name>
       <servlet-class>
           org.springframework.web.servlet.DispatcherServlet
       </servlet-class>
       <!-- 配置Spring MVC加载配置文件路径 -->
       <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:springmvc-config.xml</param-value>
       </init-param>
       <!-- 配置服务器启动后立即加载Spring MVC配置文件 -->
       <load-on-startup>1</load-on-startup>
   </servlet>
  <servlet-mapping>
       <servlet-name>springmvc</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>

springmvc-config.xml 里边的内容

1. 定义组件扫描器，指定需要扫描的包

<!-- 定义组件扫描器，指定需要扫描的包 -->
	<context:component-scan base-package="com.xiucai.controller" />

为了实现，简化复杂的装配流程，避免在xml写大量的bean id class 语句，进行对某个包下的类的扫描

2. Spring MVC的注解驱动

<!-- 加载注解驱动 -->
<mvc:annotation-driven></mvc:annotation-driven>

3.静态资源访问设置，不被前端控制器拦截

<mvc:resources location="/js/"  mapping="/js/**" />
    <mvc:resources location="/css/"  mapping="/css/**" />
    <mvc:resources location="/img/"  mapping="/img/**" />
     <mvc:resources location="/bootstrap/"  mapping="/bootstrap/**" />
    <mvc:resources location="/fonts/"  mapping="/fonts/**" />
    <mvc:resources location="/font-awesome-4.7.0/"  mapping="/font-awesome-4.7.0/**" />
     <mvc:resources location="/pages/"  mapping="/pages/register.jsp" />
    <mvc:resources location="/WEB-INF/pages/error/" mapping="/WEB-INF/pages/error/**"/> 
    <mvc:resources location="/upload/" mapping="/upload/**"/> 
        <mvc:resources location="/layer/" mapping="/layer/**"/> 
        <mvc:resources location="/layui-v2.6.8/" mapping="/layui-v2.6.8/**"/>

之前在前端控制器那边是全都拦截的。

4. 解决中文乱码问题

    <!-- 处理请求时返回json字符串的中文乱码问题 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                        <value>application/json;charset=UTF-8</value>
                    </list>
                </property>
            </bean>
            <bean id="fastJsonHttpMessageConverter" class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                        <value>application/json;charset=UTF-8</value>
                    </list>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

applicationContext.xml里

1.事务管理器

<!-- 事务管理器，依赖于数据源 --> 
	<bean id="transactionManager" class=
     "org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

2.开启事务注解

<tx:annotation-driven transaction-manager="transactionManager"/>

3.基于MapperScannerConfigurer的整合

为了比避免像传统Dao一样实现，出现代码冗余臃肿，我们采用易中自动扫描的形式来配置MyBatis中的映射器

<!-- 扫描mapper文件,mybatis中数据库相关 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.xiucai.dao"></property>
</bean>

4.开启注解扫描的配置代码，扫描service

<!-- 扫描service -->
<context:component-scan base-package="com.xiucai.service"></context:component-scan>

5 .视图解析器 ViewResolver

<!-- 定义视图解析器 -->
	<bean id="viewResolver" class=
    "org.springframework.web.servlet.view.InternalResourceViewResolver">
	     <!-- 设置前缀 -->
	     <property name="prefix" value="/WEB-INF/pages/" />
	     <!-- 设置后缀 -->
	     <property name="suffix" value=".jsp" />
	</bean>

跳转视图的时候哦只需要用简称就可以了

6. 引入properties

<!-- 读取db.propertties -->
    <context:property-placeholder location="classpath:db.properties"/>

7. 开启事务管理器，依赖于数据源

<!-- 事务管理器，依赖于数据源 --> 
	<bean id="transactionManager" class=
     "org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

8. 配置Mybatis工厂

 <!--配置MyBatis工厂 -->
    <bean id="sqlSessionFactory" 
            class="org.mybatis.spring.SqlSessionFactoryBean">
         <!--注入数据源 -->
         <property name="dataSource" ref="dataSource" />
         <!--指定核心配置文件位置 -->
   		<property name="configLocation" value="classpath:mybatis-config.xml"/>
   </bean>

可以直接生成得到sqlsession，不必要去构造工厂

9.扫描mapper

<!-- 扫描mapper文件,mybatis中数据库相关 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.xiucai.dao"></property>
</bean>

只不过这里我们没有写mapper写的是dao

log4j.properties

# Global logging configuration
log4j.rootLogger=ERROR, stdout
# MyBatis logging configuration...
log4j.logger.com.xiucai=DEBUG
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

这是能检测SQL语句的，所以要使用他。

mybatis-config.xml

<typeAliases>
<package name="com.xiucai.po"/>
</typeAliases>

分页插件

<!-- 分页插件配置  -->
    <plugins>
        <!-- com.github.pagehelper为PageHelper类所在包名 -->
        <plugin interceptor="com.github.pagehelper.PageHelper">
            <!-- 4.0.0以后版本可以不设置该参数 -->
            <!-- 该参数默认为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"/>
            <!-- 3.5.0版本可用 - 为了支持startPage(Object params)方法 -->
            <!-- 增加了一个`params`参数来配置参数映射，用于从Map或ServletRequest中取值 -->
            <!-- 可以配置pageNum,pageSize,count,pageSizeZero,reasonable,orderBy,不配置映射的用默认值 -->
            <!-- 不理解该含义的前提下，不要随便复制该配置 -->
            <property name="params" value="pageNum=start;pageSize=limit;"/>
            <!-- 支持通过Mapper接口参数来传递分页参数 -->
            <property name="supportMethodsArguments" value="true"/>
            <!-- always总是返回PageInfo类型,check检查返回类型是否为PageInfo,none返回Page -->
            <property name="returnPageInfo" value="check"/>
        </plugin>
    </plugins>

（三）文件结构

持久层 com.xiucai.po

需要注意的知识点

什么是Spring？

轻量级的java开发架构,完成对象的定义,对象的获取,对象之间的依赖关系

一站式,可以运行在服务器或者代码里

核心包括：

IOC(控制反转,对象创建的权力转移,由Spring创建对象):Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

AOP(面向切面编程),只需要写与业务相关的内容

spring 采用哪几种框架

采用三层体系架构

spring框架的优点

Spring框架的优点

非侵入设计:不用实现接口,实现接口就是代码侵入
方便解耦简化开发,像个工厂,降低主键耦合性
支持AOP:集中式的处理代码,简化代码开发
支持声明式事务处理:不用写代码处理事务,写个标签属性就可以处理事务
方便程序测试,提供Junit的支持
方便集成优秀框架,不取代,将框架整合在一起
降低JavaEE API的使用难度:对API封装,简化代码编写

让spring创建对象的实例的方法

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

<beans xmlns="http://www.springframework.org/schema/beans"
    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-4.3.xsd">
 <!-- 将指定类配置给Spring,让Spring创建其对象的实例 ,id是咱们自己定义.calss是实现类的位置-->
    <bean id="userDao" class="come.xiucai.ioc.UserDaoImpl"></bean>
   
    </beans>

测试类:

        //1.初始化容器,加载配置文件
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.通过容器获取UserDao实例,加入了强制类型转换,强制转换成我们要参加的那个
		
		UserDao userDao=(UserDao) applicationContext.getBean("userDao");
		
		//3.调用实例方法
		userDao.say();

spring获取Bean的实例的方法

getBean(String name),返回Object，这里指的name，实际上边 bean id里边的userDao

spring中依赖注入DI 与控制反转之间的关系

首先明确，是同一含义针对不同角度来看的。

控制反转，就是创建对象的控制权由原来程序本身（可以理解为class）提交到了spring容器。

对于依赖注入，是通过spring而言，是spring将要用的对象传入了程序中

spring中常用的注入方式

这是非常常用的方式，在后边对于项目的分析时，会经常用到，但是一般都是基于注解的注入

属性setter方法注入，使用bean的setter的方法完成注入

例子，解释一下：将userDao对象注入到userService对象中

就类似于class userService（）{

void Io（UserDao userDao）；

}

  <!-- 将指定类配置给Spring,让Spring创建其对象的实例 -->
    <bean id="userDao" class="come.xiucai.ioc.UserDaoImpl"></bean>
<!--添加一个ID为userService的实例-->
  
  
    <bean id="userService" class="come.xiucai.ioc.UserServiceImpl">
   <!-- 将ID为userDAO的Bean实例,注入到userService ,去向userDAO来自于 userDao-->
    <property name="userDAO" ref="userDao"></property>

package come.xiucai.ioc;

public class UserServiceImpl implements UserService{
     //声明userDao这个属性
	private UserDao userDAO;
	//添加userDao属性的方法,用于实现用户依赖注入
	public void setUserDAO(UserDao userDAO) {
		this.userDAO = userDAO;
	}
	@Override
	public void say() {
	
		this.userDAO.say();
		System.out.println("userService say hello World");
	}
	

}

想注入进来的是userDAO，他实际注入进来的是userDao

构造方法注入
注解方法注入

bean的属性

bean元素中 id 作为唯一标识符，但是name可以对容器进行配置跟管理

如果在Bean中未指定id和nam巳，则Spri吨会将c1ass值当作id使用。

bean的实例化

构造器实例化
静态工厂实例化
实例工厂方式实例化

构造器实例化：采用无参构造函数，实例化bean

在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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
 <!-- 将指定类配置给Spring,让Spring创建其对象的实例 ,id是咱们自己定义.calss是实现类的位置-->
    <bean id="bean" class="com.xiucai.instance.contructor.Bean"></bean>
   
    </beans>

有一个默认构造器

静态工厂实例化

通过工厂里边的方法进行

关键定义到MyBeanFctory以后,也要找到静态的方法

 <bean id="bean2" class="com.xiucai.instance.static_factory.MyBeanFctory " factory-method="createBean"></bean>

package com.xiucai.instance.static_factory;

public class MyBeanFctory {

	public static BeanFruit createBean() {
		return new BeanFruit();
}

}

注：静态方法是什么？静态方法不需要通过它所属的类的任何实例就可以被调用，因此在静态方法中不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法，但是可以直接访问所属类的静态变量和静态方法。另外，和 this 关键字一样，super 关键字也与类的特定实例相关，所以在静态方法中也不能使用 super 关键字。

实例化工厂

先通过构造器实例化，把Bean3Facory实例化，接者使用实例化对象中的方法进行相关的操作

    <bean  id="Bean3Facory" class="com.xiucai.instance.factory.Bean3Factory"> </bean>

    <bean   id ="bean3"   factory-bean="Bean3Facory" factory-method="CreatBean"></bean>

主要使用了factory-bean方法跟factory-method方法

工厂实例化,跟静态工厂很像

package com.xiucai.instance.factory;

public class Bean3Factory {
   
	public Bean3Factory() {
		// TODO Auto-generated constructor stub
	System.out.println("也被实例化了");
	}
	public Bean3 CreatBean() {
		return new Bean3();
		
	}
}

Bean的作用域

singleton作用域对于无会话状态的Bean(如Dao组件、Service组件)来说，是最理想的选择

在Spring配置文件中，Bean的作用域是通过元素的scope属性来指定的，

<bean id="scope"class="com.itheima.scope.Scope"scope="singleton">
<bean id="scope"class="com.itheima.scope.Scope"scope="prototype">

Bean的装配方式

基于XML的装配，可以理解为初始化一些内容

设值注入,需要满足:

Bean类提供一个无参构造方法
Bean类提供一个setter方法

需要使用子元素的来设置诸如之

基于property. 往里边

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

<beans xmlns="http://www.springframework.org/schema/beans"
    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-4.3.xsd">
 <!-- 将指定类配置给Spring,让Spring创建其对象的实例 ,id是咱们自己定义.calss是实现类的位置-->
 
   
   
   <bean id="user2"  class="com.xiucai.assemble.User">
   <property name="username" value="张三"></property>
      <property name="password" value="123456"></property>
         <property name="list" >
         
         <list>
         <value>牛逼</value>
         <value>牛逼2</value>
   </list>
         
         </property>
   </bean>
   
   
   
   
    </beans>

构造注入 .需要使用元素里的子元素定义构造方法的参数,可以使用value来设置参数的值

基于构造注入的设置方式,实际上提供了一个值

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

<beans xmlns="http://www.springframework.org/schema/beans"
    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-4.3.xsd">
 <!-- 将指定类配置给Spring,让Spring创建其对象的实例 ,id是咱们自己定义.calss是实现类的位置-->
    <bean id="user1" class="com.xiucai.assemble.User">
    <constructor-arg index="0" value="tom">  </constructor-arg>
    <constructor-arg index="1" value="12345">  </constructor-arg>
    <constructor-arg index="2" >
    <list><value>"constuctore1"</value>
    <value>"constuctore2"</value></list>
      </constructor-arg>
    </bean>
   
    </beans>

基于Annotation的装配

以上主要是对于bean的不同层提出对于不同bean 实例化的一些方式，

对于以下的解释

对于几个注释

归根到底像是一个无参构造函数把对象注入进取了

简化注解xml的方法

将如下代码

替换为

自动装配方式

在bean属性中:autowire

<bean id="userService" class="com.itheima.ioc.UserServiceImpl" autowire="byName"></bean>

autowire的几个属性值：

UserServiceImpl中有叫userDao的属性，根据名称会自动装配进去

面向切面编程 AOP是什么

举个例子，如果要记录日志，比如用户登录，本来你想要记录，写入的内容是：“登陆时间”+用户名，现在想改成，“登陆时间”+加用户名+加手机号，如果对多个方法下，应用，或者记录多个日志，比如说这只是一个登录，还想进行，注册的日志等等

是什么？

AOP采取横向抽取机制，将分散在各个方法中的
重复代码提取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方

CGLIB与JDK之间的区别

JDK要求使用动态代理的对象必须实现一个或多个接口。如果要对没有实现接口的类进行代理，那么可以使用CGLIB代理。

Spring的通知类型

MethodBeforeAdvice 前置通知
AfterReturningAdvice 后置通知
MethodInterceptor 环绕通知

AspectJ是基于Java语言的AOP框架

一个aop:config元素中又可以包含属性和子元素，其子元素包括aop:pointcut、aop:advisor
和aop:aspect,这三个子元素必须按照顺序来定义

spring事务的实现方式

传统的编程式事务管理:我们自己编写代码实现事务管理
声明式事务管理：通过AOP技术实现的事务管理

mybatis 中 #{}和 ${}的区别是什么？

#{}是预编译处理，${}是字符替换。在使⽤ #{}时，mybatis 会将 sql 中的 #{}替换成“?”，配合 PreparedStatement 的 set ⽅法赋值，这样可以有效的防⽌ sql 注⼊，保证程序的运⾏安全。

所以想要眈能实现棋糊查询，又要防止SQL注入

select * from  t_customer where username like concat ( '%'，#{value)，'%')

用另一种方法可以避免出现多数据库不兼容的问题。使用concat只针对mysql数据库

SqlSessionFactory 和SqlSession

SqISessionFactory对象是线程安全的，它一旦被创建，在整个应用执行期间都会存在。

SqlSession是应用程序与持久层之间执行交互操作的一个单线程对象，其主要作用是执行持久化操作。每一个线程都应该有自己的SqlSession实例，所以该实例不能够被共享。

Mybatis的一级缓存和二级缓存

⼀级缓存：基于 PerpetualCache 的 HashMap 本地缓存，它的声明周期是和 sqlSession ⼀致的，有多个 sqlSession 或者分布式的环境中数据库操作，可能会出现脏数据。当 Session flush 或 close 之后，该 Session 中的所有 Cache 就将清空，默认⼀级缓存是开启的。

⼆级缓存：也是基于 PerpetualCache 的 HashMap 本地缓存，不同在于其存储作⽤域为 Mapper 级别的，如果多个sqlSession之间需要共享缓存，则需要使⽤到⼆级缓存，并且⼆级缓存可⾃定义存储源，如 Ehcache。默认不打开⼆级缓存，要开启⼆级缓存，使⽤⼆级缓存属性类需要实现 Serializable 序列化接⼝(可⽤来保存对象的状态)。

resultMap元素，

定义映射规则，和用于处理多表时的关联关
系，特别是在处理表名与POJO类名不相同的时候，column是指的表中的列，而元素主要用于处理一个单独的数据库查询返回很多不同数据类型结果集的
情况。

对于嵌套结果与嵌套查询的认识

嵌套结果：<!一嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集一〉

嵌套查询：执行另外一条SQL语句来映射结果

Spring mvc 是什么

一个基于Web MVC设计模式的轻量级Web框架。

其优点

到底servlet 是什么？

servlet主要就是处理页面传过来的表单数据,页面上的form的action指向到web.xml中,然后在XML中对称节点中找到对应的servlet类去执行你的处理方法.
servlet中使用HttpServletRequest和HttpServletResponse来接受和返回数据

Spring MVC的主要组件

Spring mvc的运行流程

RequestMapping RequestBody ResponseBody 的作用

RequestMapping ：找到Controller类以后必须知道控制器，必须知道每一个请求是如何处理的。

故把它用在一个请求或者方法上。用在方法上时，会在接收到对应的URL请求时被调用。

RequestBody ：将请求体的数据绑定到方法的形参中

ResponseBody ：用于返回return对象，用在方法上

在二哥的面试宝典中：将http的请求映射到相应的类/方法上。

为了省略掉时POST 还是GET ，省略method属性，分化了组合注解

Spring MVC 当中常见的返回类型及其区别

常见的返回类型是ModelAndView、String和void。其
中ModelAndView类型中可以添加Model数据，并指定视图jString类型的返回值可以跳
转视图，但不能携带数据;而void类型主要在异步请求时使用，它只返回数据，而不会跳
转视图。

其中String类型中，可以进行重定向与请求转发

什么是数据绑定？

既执行程序时，SpringMVC 把请求信息中的信息以一定的方式转换到方法参数中。

数据绑定的方法

从浏览器地址中获取

访问：

针对简单的数据绑定，如果前端传过来的 id=xxx 与后边的参数名字相同不用，但如果前边传过来的叫nb——id，而后端依然为id，那么就需要@RequestParam(value=“user_id”)

绑定pojo类，借助表单，html里边要进行一些操作，如果前后端的 username 能对应起来。就可以直接用

秀才大大

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
基于SSM的校园二手交易网站，对于SSM的复盘。一些面试常用的问题。

代码我没有放上来，有需要的可以关注我私信我要，免费的，这是在去年的时候做的一个课程设计，我简单实现了后台管理，跟前端页面展示，重写了前端页面。但是对于具体的订单模块没有实现，针对于一般的课程设计这些工作量还是可以的，可以拿过去自己重新完成一下没有实现的模块，对于刚学习完SSM 对于框架的整合是非常友好的。主要是有一些SSM的内容是我认为面试长问的。在这里也感谢王二，二哥的一些面试常用问题。一、对于数据库的分析分析一下每个表之间的联系，数据库表为什么要这样设计。admin：最值得一提的是.
复制链接

扫一扫