一、对于数据库的分析

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核心

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

（二）配置文件

web.xml 里的内容

1. 创建spring的容器ApplicationContext

<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的整合

<!-- 扫描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>

9.扫描mapper

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

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的方法完成注入

  <!-- 将指定类配置给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();
}

}

实例化工厂

    <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属性中:autowire

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

autowire的几个属性值：

面向切面编程 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)，'%')

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

Spring MVC的主要组件

Spring mvc的运行流程

RequestMapping RequestBody ResponseBody 的作用

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

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

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

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

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

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

什么是数据绑定？

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

数据绑定的方法

访问：

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