Spring+Spring MVC+MyBatis 开发知识点

已于 2022-06-07 08:06:06 修改
阅读量1k 收藏 2
点赞数 3
文章标签： spring mvc java
于 2022-06-06 22:47:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rourf/article/details/125156020
版权

第一章 初识MyBatis框架

1.1 MyBatis核心配置文件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>
    <!-- 环境配置 -->
    <!-- 加载类路径下的属性文件 -->
    <properties resource="db.properties"/>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!-- 数据库连接相关配置 ,db.properties文件中的内容-->
            <dataSource type="POOLED">
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="${mysql.username}"/>
                <property name="password" value="${mysql.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- mapping文件路径配置 -->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/> 如果有多个映射文件，需要配置多个mapeer元素指定映射文件的路径
    </mappers>
</configuration>

1.2 UserMapper.xml用于配置SQL语句和JAVA对象之间的映射

SQL映射文件 ，该文件配置了操作数据库的SQL语句

<?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">
<!-- 2-4行映射文件的约束信息-->
<!-- mapper为映射的根节点-->
<!-- mapper为映射的根节点，namespace指定Dao接口的完整类名
mybatis会依据这个接口动态创建一个实现类去实现这个接口，
而这个实现类是一个Mapper对象-->
<mapper namespace="com.itheima.pojo.User"> namespace用于标识映射文件，namespace属性的值通常设置为对应接口的全限定类名
    <!--id ="接口中的方法名"
　　parameterType="传入的参数类型"
　　resultType = "返回实体类对象，使用包.类名"-->
    <select id="findById" parameterType="int"
            resultType="com.itheima.pojo.User"> id属性用于唯一标识该SQL语句块，JAVA代码通过id属性的值找到对应的SQL语句块
	 	select * from users where uid = #{id}
	</select>
</mapper>

1.3 构造会话工厂

通过MyBatis的环境等配置信息构建会话工厂SqlSessionFactory用于创建SqlSeesion

1.4 构建会话对象

由会话工厂SqlSeesionFactory创建SQLSession对象，该对象包含了执行SQL语句的所有方法

第二章MyBatis的核心配置

使用MyBatis框架解决持久化问题，主要涉及3个核心对象，分别是SqlSeesionFactoryBuilder、SqlSEesionFatory和SqlSeesion。

2.1 SqlSeesionFactoryBuilder

SqlSeesionFactoryBuilder就是SqlSEesionFatory的构造者

2.2 SqlSEesionFatory

SqlSEesionFatory用于创建SqlSeesion对象

2.3 SqlSeesion

主要执行持久化操作

推荐使用 getMapper方法

2.4 mappers元素

用于引入Mybatis映射文件，有四种方法

2.4.1 使用类路径引入

<mappers>
	<mapper resource="com.xx.user.xml" />
</mappers>

2.4.2 使用本地文件路径引入

<mappers>
	<mapper url="file:///D:/xx/uer.xml" />
</mappers>

2.4.3 使用接口类引入

<mappers>
	<mapper class="com.user" />
</mappers>

2.4.4 使用包名引入

<mappers>
	<mapper name="com.user" />
</mappers>

2.5 MaBatis映射文件中常用的元素

Mybatis会通过接口的全限定类名查找到对应的mapper配置来执行SQL语句

2.6 select元素

用于映射查询语句，它可以从数据库中查询数据并返回。

<select id="findById" parameterType="integer" resultType="cn.goktech.bean.User">
    select * from users where uid = #{uid}
</select>

上述语句id属性值为findById，parameterType属性为Integer表示接收一个int类型的参数，resultType的值为User类的全限定类名，表示返回一个USer类型的对象，参数符号#{}表示创建一个预处理语句参数，resultType与resultMap不能同时使用，对象名与列名不一样的时候使用，数据记录较多的时候使用。

2.7 insert元素

返回已插入记录的数量

<insert id="xx" parameterType="xx.xx.user">
    insert into users(xx,xx)values(xx,xx)
</insert>

2.8 update元素

返回更新的记录数量

<update id="xx" parameterType="xx.xx.xx.user">
	update users set username = #{uname}
</update>

2.9 sql元素

定义一个可复用的sql代码片段

<sql id="xx">${xx}.uid,${xx}.uname</sql>
<seletct>
	select <include refid="xx"/>
</seletct>

使用元素的refid属性引用了自定义的代码片段，refid属性的值为自定义代码片段的id

2.10 resultMap元素

默认情况下，mybatis程序在运行时会自动将查询到的数据与需要返回的对象的属性进行匹配复制，若数据表中列和需要返回的对象的属性可能不会完全一致，就需要使用元素进行结果集的映射

<?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="com.itheima.mapper.StudentMapper">
    <resultMap type="com.itheima.pojo.Student" id="studentMap">
        <id property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="age" column="sage"/>
    </resultMap>
    <select id="findAllStudent" resultMap="studentMap">
   			select * from t_student
   		</select>
</mapper>

第三章 动态SQL

3.1 动态SQL中的元素

判断语句，用于单条件判断

(、)相当于JAVA中的SWITCH、CASE、DEFAULT语句，用于多条件判断

简化SQL语句中的where条件判断

循环语句，常用语in语句等列举条件中

<?xml version="1.0" encoding="UTF8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.mapper.CustomerMapper">
    <!-- <if>元素使用 -->
    <select id="findCustomerByNameAndJobs"
            parameterType="com.itheima.pojo.Customer"
            resultType="com.itheima.pojo.Customer">
        select * from t_customer
        <!--where 1=1 -->
        <!-- <where> -->
            <trim prefix="where" prefixOverrides="and">
                <if test="username !=null and username !=''">
                    and username like concat('%',#{username}, '%')
                </if>
                <if test="jobs !=null and jobs !=''">
                    and jobs= #{jobs}
                </if>
            </trim>
        <!--</where> -->
    </select>

    <!--<choose>(<when>、<otherwise>)元素使用 -->
    <select id="findCustomerByNameOrJobs"
            parameterType="com.itheima.pojo.Customer"
            resultType="com.itheima.pojo.Customer">
        select * from t_customer where 1=1
        <choose>
            <!--条件判断 -->
            <when test="username !=null and username !=''">
                and username like concat('%',#{username}, '%')
            </when>
            <when test="jobs !=null and jobs !=''">
                and jobs= #{jobs}
            </when>
            <otherwise>
                and phone is not null
            </otherwise>
        </choose>
    </select>

    <!-- <set>元素 -->
    <update id="updateCustomerBySet"
            parameterType="com.itheima.pojo.Customer">
        update t_customer
        <set>
            <if test="username !=null and username !=''">
                username=#{username},
            </if>
            <if test="jobs !=null and jobs !=''">
                jobs=#{jobs},
            </if>
            <if test="phone !=null and phone !=''">
                phone=#{phone},
            </if>
        </set>
        where id=#{id}
    </update>

    <!-- <trim>元素 -->
    <update id="updateCustomerByTrim"
            parameterType="com.itheima.pojo.Customer">
        update t_customer
        <trim prefix="set" suffixOverrides=",">
            <if test="username !=null and username !=''">
                username=#{username},
            </if>
            <if test="jobs !=null and jobs !=''">
                jobs=#{jobs},
            </if>
            <if test="phone !=null and phone !=''">
                phone=#{phone},
            </if>
        </trim>
        where id=#{id}
    </update>

    <!--<foreach>元素使用 -->
    <select id="findByArray" parameterType="java.util.Arrays"
            resultType="com.itheima.pojo.Customer">
        select * from t_customer where id in
        <foreach item="id" index="index" collection="array"
                 open="(" separator="," close=")">
            #{id}
        </foreach>
    </select>

    <!--<foreach>元素使用 -->
    <select id="findByList" parameterType="java.util.Arrays"
            resultType="com.itheima.pojo.Customer">
        select * from t_customer where id in
        <foreach item="id" index="index" collection="list"
                 open="(" separator="," close=")">
            #{id}
        </foreach>
    </select>

    <!--<foreach>元素使用 -->
    <select id="findByMap" parameterType="java.util.Map"
            resultType="com.itheima.pojo.Customer">
        select * from t_customer where jobs=#{jobs} and id in
        <foreach item="roleMap" index="index" collection="id"
                 open="(" separator="," close=")">
            #{roleMap}
        </foreach>
    </select>

</mapper>

3.2 foreach元素属性

item 表示集合中每个一个元素进行迭代时的别名，必选属性

index 在List和数组中，index是元素的序号，在Map中，index是元素的Key，该属性为可选属性

separator 表示元素之间的分隔符

collection 用于指定遍历参数的类型

第四章 MyBatis的关联映射和缓存机制

4.1 一对一查询

元素来处理一对一关联关系

4.1.1 association元素中的属性

property 用于指定映射到实体类对象的属性，与表字段一一对应

column 用于指定表中对应的字段

javaType 用于指定映射到实体对象的属性的类型

jdbcType 用于指定数据表中对应字段的类型

fetchType 用于指定在关联查询时是否启用延迟加载。有两个属性lazy和eager属性，默认值为lazy

select 用于指定引入嵌套查询的子SQL语句，该属性用于关联映射中的嵌套查询

autoMapping 用于指定是否自动映射

typeHandler 用于指定一个类处理器

4.1.2 嵌套查询方式

通过执行另外一条SQL映射语句来返回预期的复杂类型

<association property="card" column="card_id"
javaType="xxx.xxx.user"
select="xxx.xxx.mapper.usermapper.findcodeById"/>

4.1.3 嵌套结果方式

使用嵌套结果映射来处理重复的联合结果的子集

<association property="card"javaType="xxx.xxx.user">
    <id property="id" column="card_id" />
    <result property="code" column="code" />
</association>

4.2 一对多查询

通过元素来处理一对多关联关系，包含特殊属性–ofType和javaType差不多

4.2.1 嵌套查询

<collection property="xx" column="id"
            ofType="xx.xx.user"
            select="xx.xx.mapper.seleuser"/>

4.2.2 嵌套结果

<collection property="card"ofType="xxx.xxx.user">
    <id property="id" column="id" />
    <result property="number" column="number" />
</collection>

4.3 MyBatis一级缓存

是SQLSession级别的缓存

4.4 二级缓存

是Mapper级别的缓存

第五章 MyBatis的注释开发

5.1 @Param注释

指定SQL语句中的参数，通常用于SQL语句中参数比较多的情况

@Select("select * from tb_worker where id = #{param01} " + "and name = #{param02}")
Worker selectWorkerByIdAndName(@Param("param01") int id,@Param("param02") String name);

id和name这两个参数要与#{}一一对应

第六章 初识Spring框架

6.1 Spring核心的理念

是控制反转IOC和面向切面编程AOP

6.2 Spring框架优点

Spring作为JAVA EE 的一个全方位应用程序框架（放在框架中可用任何位置）可用用于JAVA应用的开发、服务器端开发

6.2.1 降低耦合性，方便开发

6.2.2 支持AOP编程

6.2.3 降低JavaEE API的使用难度

6.3 Spring核心容器

6.3.1 Beans模块

6.3.2 core模块

6.3.3 Context模块

6.3.4 SqEL模块

6.4 控制反转概念

使用SPring后，对象实例不再由调用者来创建，而是由IOC容器来创建，IOC容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制的。

6.5 依赖注入的概念

依赖注入DI是指IOC容器在运行期间动态地将某种依赖资源注入到对象中。

6.6 依赖注入的类型

依赖注入指的是使用Spring框架创建对象时，动态地将其所依赖的对象注入到Bean组件中。一种是构造方法注入，另一种是属性setter方法注入。

6.6.2 属性setter方法注入

属性setter方法注入是Spring主流的注入方法，在类声明一个setter方法

第七章 Spring中的Bean的管理

7.1 ApplicationContex接口

ClassPathXMlApplicationContext 从路径类加载配置文件，实例化ApplicationContext接口

7.2 Bean的配置

元素的常用子元素

img

7.3 Bean的实例化

实例化Bean有3种方法，构造方法实例化、静态工厂实例化、实例工厂实例化

7.5 Bean的装配方法

3种常用的Bean装配方式，分别是基于XML的装配、基于注释的装配和自动装配

7.5.1 基于XML的装配

1.属性setter方式注入
<bean id="bean1" class="com.itheima.Bean1">
	<property name="id" value="2"></property>
</bean>
2.构造方法注入
<bean id="bean1" class="com.itheima.Bean1">
	<constructor-arg name="id" value="1"></constructor-arg>
</bean>

7.5.2 基于注释的装配

@Component该注解用于描述 Spring 中的 Bean，它是一个泛化的概念，仅仅表示容器中的一个组件(Bean)，并且可以作用在应用的任何层次，例如 Service 层、Dao 层等。 使用时只需将该注解标注在相应类上即可。
@Repository该注解用于将数据访问层(Dao 层)的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Service该注解通常作用在业务层(Service 层)，用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Controller该注解通常作用在控制层(如 Struts2 的 Action、SpringMVC 的 Controller)，用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Autowired可以应用到 Bean 的属性变量、setter 方法、非 setter 方法及构造函数等，默认按照 Bean 的类型进行装配。 @Autowired 注解默认按照 Bean 的类型进行装配，默认情况下它要求依赖对象必须存在，如果允许 null 值，可以设置它的 required 属性为 false。如果我们想使用按照名称(byName)来装配，可以结合 @Qualifier 注解一起使用

7.6 请简述XML配置文件的根元素中的常用元素及作用

l id：id属性是元素的唯一标识符,Spring容器对Bean的配置和管理通过id属性完成,装配Bean时也需要根据id值获取对象。

l name：name属性可以为Bean指定多个名称,每个名称之间用逗号或分号隔开。

l class：class属性可以指定Bean的具体实现类,其属性值为对象所属类的全路径。

l scope：scope属性用于设定Bean实例的作用范围,其属性值有：singleton（单例）、prototype（原型）、request、session和global session。

第八章 Spring AOP

8.1 AOP术语

8.1.1 切面ASPECT

8.1.2 连接点Joinpoint

程序执行过程的中某个特定的点

8.1.3 切入点Pointcut

切面与连接点的交叉，是切面和程序流程的交叉点

8.2 AOP的实现机制

可以将AOP实现机制分为两种，一种是JDK动态代理，另一种是GGLib动态代理

JDK动态代理必须实现接口

8.2.1 GGLib动态代理

JDK存在缺陷，只能为接口创建代理对象，当需要为类时候，使用GGLib，通过继承的方式动态创建代理对象，Spring核心包已经集成了GGLib所需要的包，所以在开发中不需要另外导入JAR包

8.3 AOP的XML元素

aop:conifg 配置的根元素

aop:aspect 配置切面 通过ref属性即可应用该Bean

aop:advisor 配置通知器

aop:pointcut 配置切入点

aop:before 配置前置通知

aop:after 配置后置通知 等同finally

8.4 基于注解的AOP实现

1.@Before

@Before：在切点方法前执行

2.@After

@After：早切点方法后执行

3.@Around

@Around：在切点方法外环绕执行

4.@AfterReturning

@AfterReturning：在方法返回之前，获取返回值并进行记录操作

5.@AfterThrowing

@AfterThrowing：@AfterThrowing:配置异常通知

6.@Aspect 配置切面

7.Pointcut 配置切入点

第九章 Spring的数据库编程

9.1 applicationContext.xml

配置id为dataSource的数据源Bean和id为jdbcTempla的JDBC模板Bean，并将数据源注入JDBC模板中

9.2 TestJdbcTemplate.java

package com.itheima;
import org.springframework.context.ApplicationContext;
import
        org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
public class TestJdbcTemplate {
    /**
     * 调用execute()方法建表
     */
    public static void main(String[] args) {
        // 初始化spring容器，加载applicationContext.xml配置
        ApplicationContext applicationContext = new
                ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过容器，获取JdbcTemplate的实例
        JdbcTemplate jdTemplate =
                (JdbcTemplate) applicationContext.getBean("jdbcTemplate");
        // 使用execute()方法执行SQL语句，创建用户账户管理表account
        jdTemplate.execute("create table account(" +
                "id int primary key auto_increment," +
                "username varchar(50)," +
                "balance double)");
        System.out.println("账户表account创建成功！");
    }
}

9.2 update()方法

方法说明
int update(String sql)直接传入SQL语句，并返回受影响的行数
int update(PreparedStatementCreator psc)执行从PreparedStatementCreator返回的语句，然后返回受影响的行数
int update(String sql,PreparedStatementSetter pss)通过PreparedStatementSetter设置SQL语句中的参数，并返回受影响的行数
int update(String sql,Object…args)使用Object…设置SQL语句中的参数，参数不能为NULL，并返回受影响的行数

9.3 query()方法

JdbcTemplate中常用的query()方法

方法说明
List query(String sql,RowMapper rowMapper)执行String类型参数提供的SQL语句，并通过RowMapper返回一个List类型的结果
List query(String sql,PreparedStatementSetter pss,RowMapper rowMapper)根据String类型参数提供的SQL语句创建PreparedStatement对象，通过RowMapper将结果返回到List中
List query(String sql,Object[] args,RowMapper rowMapper)使用Object[]的值来设置SQL语句中的参数值，采用RowMapper回调方法可以直接返回List类型的数据
queryForObject(String sql,RowMapper rowMapper,Object…args)将args参数绑定到SQL语句中，并通过RowMapper返回一个Object类型的单行记录
queryForList(String sql,Object[] args,classelementType)该方法可以返回多行数据的结果，但必须是返回列表，elementType参数返回的是List元素类型

9.4事务管理的核心接口

spring-tx-3.2.13.RELEASE.jar

这三个核心接口的作用及其提供的方法如下。

1. PlatformTransactionManager:用于根据属性管理事务

PlatformTransactionManager 接口是 Spring 提供的平台事务管理器，用于管理事务。该接口中提供了三个事务操作方法，具体如下。

  • TransactionStatus getTransaction（TransactionDefinition definition）：用于获取事务状态信息。
  • void commit（TransactionStatus status）：用于提交事务。
  • void rollback（TransactionStatus status）：用于回滚事务。

在项目中，Spring 将 xml 中配置的事务详细信息封装到对象 TransactionDefinition 中，然后通过事务管理器的 getTransaction() 方法获得事务的状态（TransactionStatus），并对事务进行下一步的操作。

2. TransactionDefinition:用于定义事务的属性

TransactionDefinition 接口是事务定义（描述）的对象，它提供了事务相关信息获取的方法，其中包括五个操作，具体如下。

  • String getName()：获取事务对象名称。
  • int getIsolationLevel()：获取事务的隔离级别。
  • int getPropagationBehavior()：获取事务的传播行为。
  • int getTimeout()：获取事务的超时时间。
  • boolean isReadOnly()：获取事务是否只读。

在上述五个方法的描述中，事务的传播行为是指在同一个方法中，不同操作前后所使用的事务。传播行为的种类如表 1 所示。

表 1 传播行为的种类

属性名称值描 述
PROPAGATION_REQUIREDrequired支持当前事务。如果 A 方法已经在事务中，则 B 事务将直接使用。否则将创建新事务
PROPAGATION_SUPPORTSsupports支持当前事务。如果 A 方法已经在事务中，则 B 事务将直接使用。否则将以非事务状态执行
PROPAGATION_MANDATORYmandatory支持当前事务。如果 A 方法没有事务，则抛出异常
PROPAGATION_REQUIRES_NEWrequires_new将创建新的事务，如果 A 方法已经在事务中，则将 A 事务挂起
PROPAGATION_NOT_SUPPORTEDnot_supported不支持当前事务，总是以非事务状态执行。如果 A 方法已经在事务中，则将其挂起
PROPAGATION_NEVERnever不支持当前事务，如果 A 方法在事务中，则抛出异常
PROPAGATION.NESTEDnested嵌套事务，底层将使用 Savepoint 形成嵌套事务

在事务管理过程中，传播行为可以控制是否需要创建事务以及如何创建事务。

通常情况下，数据的查询不会改变原数据，所以不需要进行事务管理，而对于数据的增加、修改和删除等操作，必须进行事务管理。如果没有指定事务的传播行为，则 Spring3 默认的传播行为是 required。

3. TransactionStatus:用于界定事务的状态

TransactionStatus 接口是事务的状态，它描述了某一时间点上事务的状态信息。其中包含六个操作，具体如表 2 所示。

表 2 事务的操作

名称说明
void flush()刷新事务
boolean hasSavepoint()获取是否存在保存点
boolean isCompleted()获取事务是否完成
boolean isNewTransaction()获取是否是新事务
boolean isRollbackOnly()获取是否回滚
void setRollbackOnly()设置事务回滚

9.5 基于注解方式的声明式事务

@Transaction 注解通常应用在业务实现类上（service），使用时，还需在Spring的XML文件中通过tx:annotation-driven元素配置事务注解驱动，tx:annotation-driven元素中有一个常用属性transaction-manager，该属性用于指定事务管理器。

9.6 applicationContext-annotation.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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx
    http://www.springframework.org/schema/tx/spring-tx.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">
    <!-- 1.配置数据源 -->
    <bean id="dataSource"
          class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!--数据库驱动 -->
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <!--连接数据库的url -->
        <property name="url" value="jdbc:mysql://localhost/spring?useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=Asia/Shanghai" />
        <!--连接数据库的用户名 -->
        <property name="username" value="root" />
        <!--连接数据库的密码 -->
        <property name="password" value="root" />
    </bean>
    <!-- 2.配置JDBC模板 -->
    <bean id="jdbcTemplate"
          class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 默认必须使用数据源 -->
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!--3.定义id为accountDao的Bean -->
    <bean id="accountDao" class="com.itheima.AccountDaoImpl">
        <!-- 将jdbcTemplate注入到AccountDao实例中 -->
        <property name="jdbcTemplate" ref="jdbcTemplate" />
    </bean>
    <!-- 4.事务管理器，依赖于数据源 -->
    <bean id="transactionManager" class=
            "org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 5.注册事务管理器驱动 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

第十章 初始Spring MVC框架

在此对Spring MVC的三大组件进行讲解，这三大组件分别是处理器映射器（HandlerMapping）、处理器适配器（HandlerAdapter）和视图解析器（ViewResolver）。

10.1 MVC 工作执行流程

（1）用户通过浏览器向服务器发送请求，请求会被Spring MVC的前端控制器DispatcherServlet拦截。

（2）DispatcherServlet拦截到请求后，会调用HandlerMapping（处理器映射器）。

（3）处理器映射器根据请求URL找到具体的处理器，生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispatcherServlet。

（3）DispatcherServlet会通过返回信息选择合适的HandlerAdapter（处理器适配器）。

（4）HandlerAdapter会调用并执行Handler（处理器），这里的处理器指的就是程序中编写的Controller类，也被称之为后端控制器。

（5）Controller执行完成后，会返回一个ModelAndView对象，该对象中会包含视图名或包含模型和视图名。

（6）HandlerAdapter将ModelAndView对象返回给DispatcherServlet。

（7）前端控制器请求视图解析器根据逻辑视图名解析真正的视图。

（8）ViewResolver解析后，会向DispatcherServlet中返回具体的View（视图）。

（9）DispatcherServlet对View进行渲染（即将模型数据填充至视图中）。

（10）前端控制器向用户响应结果。

10.2 小提示

快捷的配置处理器和映射器和处理器适配器，也可以在配置文件中使用，mvc:annotation-driven元素来实现，该元素会自动注册处理器映射器和处理器适配器

第十一章 MVC的核心类和注解

11.1 @Controller

11.2 @RequestMapping

  1. value：指定请求的实际地址，像/action/info这样的。
  2. method：指定请求的method类型， GET、POST、PUT、DELETE等。
  3. produces：它的作用是指定返回内容的类型，只有当request请求头中Accept属性包含该produces指定的类型才能返回数据成功。注意：请求头中国Accept代表发送端（客户端）希望接受的数据类型，比如：Accept：text/xml（application/json），代表客户端希望接受的数据类型是xml（json）类型。
  4. consumes：它的作用是指定request请求提交的内容类型(Content-Type)，例如application/json, text/html。注意：Content-Type代表发送端（客户端|服务器）发送的实体数据的数据类型，比如：Content-Type：text/html（application/json），代表发送端发送的数据格式是html（json）。
  5. params：指定request请求地址中必须包含某些参数值，才让该方法处理。当使用params属性时，你可以让多个处理方法处理同一个URL请求地址，只需要设置请求地址的参数不同即可。支持简单的表达式：

----params = “params1”：表示请求必须包含名为params1的请求参数;
----params = “!params1”：表示请求不能包含名为params1的请求参数;
----params = “params1 != value1”：表示请求必须包含名为params1的请求参数，但是其值不能是value1;
----params = {“params1 = value1”, “param2”}：表示请求必须包含名为params1和params2两个请求参数，且params1的值必须为value1;

6.header：指定request请求中必须包含某些指定的请求头header的值，才能让该方法处理请求。

11.3 method属性

package com.itheima.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/method")
public class MethodController {
    //处理请求方式为 GET 的请求
    @RequestMapping(method = RequestMethod.GET)
    public void get() {
        System.out.println("RequestMethod.GET");
    }

    //处理请求方式为 DELETE 的请求
    @RequestMapping(method = RequestMethod.DELETE)
    public void delete() {
        System.out.println("RequestMethod.DELETE");
    }

    //处理请求方式为 POST 的请求
    @RequestMapping(method = RequestMethod.POST)
    public void post() {
        System.out.println("RequestMethod.POST");
    }

    //处理请求方式为 PUT 的请求
    @RequestMapping(method = RequestMethod.PUT)
    public void put() {
        System.out.println("RequestMethod.PUT");
    }

    @RequestMapping(value = "/method",
            method = {RequestMethod.GET,RequestMethod.POST})
    public void getAndPost() {
        System.out.println("RequestMethod.GET+RequestMethod.POST");
    }
}

11.4 基于请求方式的URL路径映射

@GetMapping：匹配GET方式的请求；
@PostMapping：匹配POST方式的请求；
@PutMapping：匹配PUT方式的请求；
@DeleteMapping：匹配DELETE方式的请求；
@PatchMapping：匹配PATCH方式的请求。

11.5 基于RESTful风格的URL路径映射

通过@PathVariable 注释可以将URL中占位符绑定到处理器的形参中

@RequestMapping("/user/{name}")
(@PathVariable (value = "name") String username)

将name和处理方法的参数username进行绑定

第十二章 MVC数据绑定和响应

12.1 编码过滤器设置

web.xml
<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>

12.2 使用DateTimeFormat注解绑定日期数据

    @RequestMapping("/getBirthday")
    public void getBirthday(@DateTimeFormat(
            pattern = "yyyy-MM-dd") Date birthday) {
        System.out.println("birthday=" + birthday);
    }

spring-mvc.xml

    <!-- 配置创建 spring 容器要扫描的包 -->
    <context:component-scan base-package="com.itheima.controller"/>
    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

12.3 集合绑定

    /**
     * 获取商品列表(使用List绑定数据)
     */
    @RequestMapping("/getProducts")
    public void getProducts(@RequestParam("proIds") List<String> proIds) {
        for (String proId : proIds) {
            System.out.println("获取到了Id为" + proId + "的商品");
        }
    }

由于List是接口，无法创建对象，所以会出现无法找到构造方式异常

12.4 表单格式

属性对象名称.属性

12.5 $ajax

$.ajax({
            url: "${pageContext.request.contextPath }/getProductList",
            type: "post",
            data: JSON.stringify([pro1, pro2]),
            contentType: "application/json;charset=UTF-8",
            dataType: "json",
            success: function (response) {
                alert(response);
            }
        });

12.6 结合Json转化器

  /**
     * 获取单个商品信息
     */
    @RequestMapping("/getProduct")
    public void getProduct(@RequestBody Product product) {
        String proId = product.getProId();
        String proName = product.getProName();
        System.out.println("获取到了Id为" + proId + "名称为" + proName + "的商品");
    }

    /**
     * 获取多个商品信息
     */
    @RequestMapping("/getProductList")
    public void getProductList(@RequestBody List<Product> products) {
        for (Product product : products) {
            String proId = product.getProId();
            String proName = product.getProName();
            System.out.println("获取到了Id为" + proId + "名称为" +
                    proName + "的商品");
        }
    }

12.7 DispatherServlet

DispatherServlet会拦截所有URL，导致项目中的静态资源（CSS、JSP、JAVAScript），可以进行静态资源配置。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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.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">
    <!-- 配置创建 spring 容器要扫描的包 -->
    <context:component-scan base-package="com.itheima.controller"/>
    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!-- 配置类型转换器工厂 -->
<!--    <bean id="converterService" class=-->
<!--            "org.springframework.context.support.ConversionServiceFactoryBean">-->
<!--        &lt;!&ndash; 给工厂注入一个新的类型转换器 &ndash;&gt;-->
<!--        <property name="converters">-->
<!--            <array>-->
<!--                &lt;!&ndash; 配置自定义类型转换器 &ndash;&gt;-->
<!--                <bean class="com.itheima.convert.DateConverter"/>-->
<!--            </array>-->
<!--        </property>-->
<!--    </bean>-->
    <!-- 装载转换器 -->
<!--    <mvc:annotation-driven conversion-service="converterService"/>-->
    <mvc:annotation-driven />
    <!--配置静态资源的访问映射，此配置中的文件，将不被前端控制器拦截 -->
    <mvc:resources mapping="/js/**" location="/js/" />

</beans>

12.8 @RresponseBody注解的作用

是将处理器返回对象通用适当的转换器转换为指定的格式之后，写入HttpServletResponse对象的body区，@ResponseBody注释通常用于返回JSON数据。

第十三章 MVC的高级功能

13.1 异常处理注释

package com.itheima.controller;

import com.itheima.exception.MyException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.ModelAndView;

import java.io.IOException;

@ControllerAdvice
public class ExceptionAdvice {
    //处理MyException类型的异常
    @ExceptionHandler(MyException.class)
    public ModelAndView doMyException(MyException ex) throws IOException {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("msg", ex.getMessage());
        modelAndView.setViewName("error.jsp");
        return modelAndView;
    }

    //处理Exception类型的异常
    @ExceptionHandler(Exception.class)
    public ModelAndView doOtherException(Exception ex) throws IOException {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("msg", "网络异常！");
        modelAndView.setViewName("error.jsp");
        return modelAndView;
    }
}

13.2 拦截器配置

mvc:interceptors元素使用两种方式配置了拦截器，其中，使用子元素声明的拦截器将会对所有的请求进行拦截；而使用mvc:interceptor元素声明的拦截器会指定路径下的请求进行拦截。

“/**”表示拦截所有路径

mvc:interceptor中子元素必须按照上述代码的配置顺序进行编写，即mvc:mapping->mvc:exclude-mapping->的顺序，否则文件会报错

13.3 登录思想

  • *我的答案：

    Controller层1、获取前端的用户名和密码2、获取数据库用户和密码（这里使用模拟）3、判断用户名是否一致 3.1若一致，则继续判断密码是否一致。一致则登录成功 ，不一致反之。 3.2若不一致，显示用户不存在请重新登录。4、登录成功，直接跳转至主页，并且把当前用户信息存放入 session作用域 5、登录失败，直接跳到到登录页，并且拦截中断请求。Intercepto层1、继承拦截器适配器，重写preHandle()2、判断请求是否是用户登录相关请求，直接放行 return true; 3、如果不是用户登录相关请求，则继续判断 session是否存在用户信息。 3.1、 如果存在用户信息，则直接放行 4、其他情况，没有存在用户信息则直接跳转到登录页，并且拦截中断请求5、需要将登录验证拦截器 注册到拦截器配置简述：获取前端的用户名和密码，验证账户密码成功后存入session作用域，继承拦截器适配器，判断是否用户登录请求，若不是，则判断session是否存放信息，存在则放行，不存在则拦截，最后将其配置到spring-mvc.xml中

  • 正确答案：

答案解析：

要实现登录验证,首先需要创建一个登录拦截器类,

该类中需要拦截除用户登录请求之外的所有请求；

并对用户的登录状态进行判断,（session）只有已登录的用户请求才能够继续执行,否则会将用户请求转发到系统登录页面,并给出登录提示。

编写完登录拦截器类后，还需要在Spring MVC的配置文件中对该拦截器类进行配置，配置完成后,即可使用

13.4 请简述进行文件上传时，表单需要满足的哪些条件。

  • *我的答案：

    大多数文件上传都是通过表单形式提交给后台服务器，因此，要实现文件上传功能，就需要提供一个文件上传的表单，并且该表单必须满足以下3个条件。form表单的method属性设置为post。form表单的enctype属性设置为multipart/form-data。提供<input type=“file” name=“filename”/的文件上传输入框。

  • 正确答案：

答案解析：

（1）form 表单的 method 属性设置为 post;

（2）form 表单的 enctype 属性设置为 multipart/form-data;

（3）提供的文件上传输入框

13.5 在MVC中使用multipartResolver接口

    <bean id="multipartResolver" class=
            "org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 设置请求编码格式，必须与JSP中的pageEncoding属性一致，默认为ISO-8859-1 -->
        <property name="defaultEncoding" value="UTF-8"/>
        <!-- 设置允许上传文件的最大值为2M，单位为字节 -->
        <property name="maxUploadSize" value="2097152"/>
    </bean>

通过元素可以对文件解析器类CommonsMultipartResolver的以下属性进行配置

maxUploadSIze：上传文件最大值（以字节为单位）

maxInMemorySize：缓存中的最大值（以字节为单位）

defaultEncoding：默认编码格式

resolveLazily：推迟文件解析，以便在Controller中捕获文件大小异常

13.6 MultipartFile接口的常用方法

byte[] getBytes()：获取文件数据
String getContentType[]：获取文件MIME类型，如image/jpeg等
InputStream getInputStream()：获取文件流
String getName()：获取表单中文件组件的名字
String getOriginalFilename()：获取上传文件的原名
Long getSize()：获取文件的字节大小，单位为byte
boolean isEmpty()：是否有上传文件
void transferTo(File dest)：将上传文件保存到一个目录文件中

13.7 文件下载

HttpStatus.Ok表示200，即服务器已经成功处理了请求，500表示服务器失败

第十四章 SSM框架整合

14.1 整合思路

  • *我的答案：

    ① 搭建项目基础结构首先需要在数据库中搭建项目对应的数据库环境；然后创建一个Maven Web项目，并引入案例所需的依赖；最后创建项目的实体类，创建三层架构对应的模块、类和接口。②整合Spring和MyBatis。在Spring配置文件中配置数据源信息，并且将SqlSessionFactory对象和Mapper对象都交由Spring管理。③ 整合Spring和Spring MVC。Spring MVC是Spring框架中的一个模块，所以Spring整合Spring MVC只需在项目启动时分别加载各自的配置即可。

  • 正确答案：

答案解析：

1）搭建项目基础结构。首先需要在数据库中搭建项目对应的数据库环境；然后创建

一个 Maven Web 项目，并引入案例所需的依赖；最后创建项目的实体类，创建三层架构对

应的模块、类和接口。

2 ） 整 合 Spring 和 MyBatis 。 在 Spring 配 置 文 件 中 配 置 数 据 源 信 息 ， 并 且 将

SqlSessionFactory 对象和 Mapper 对象都交由 Spring 管理。

3）整合 Spring 和 Spring MVC。Spring MVC 是 Spring 框架中的一个模块，所以 Spring

整合 Spring MVC 只需在项目启动时分别加载各自的配置即可。

14.2 Spring和Spring MVC无整合

14.3 Spring和Spring MVC整合只需要在项目启动时候家长Spring容器和Spring的配置文件即可。

Rourf.
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ApplicationContext接口常用实现类，在web中的实例化配置
EvelynHouseba的专栏
07-21 3374
1、Spring中加载ApplicationContext.xml文件的方式    Application contextconstructor通常使用字符串或字符串数组作为资源的定位路径（比如组成context定义的XML文件）。用于装载单个或多个XML配置文件来实例化ApplicationContext容器。 ApplicationContext接口的常用实现类：  ClassPathX
Spring IOC
呵呵彡的博客
01-26 400
Spring IOC
mybatis的框架(深入)
weixin_58276266的博客
06-22 131
此处 是使用idea进行mybatis框架 mybatis mybatis的MyBatis 是支持普通 SQL 查询,存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的 JDBC 代码和参数的手工设置以及结果集的检索。 优势: 简化JDBC的开发 能够更好的完成ORM(对象关系映射) 还提供了缓存:当第一次查询数据库的时候会执行sql语句到数据库中进行查询,那么在以后的查询就会在缓存中进行查询,不到数据库中进行查询 ; ORM:封装类的属性和表的列名进行对应(此处相当于jdb.
mybatis resultType=java.util.Map 时注意返回null
热门推荐
leehbing的博客
03-24 1万+
利用mybatis 动态查询一条记录，而返回是一个map（resultType=”java.util.Map”，键是字段名，值是字段值），比如操作数据库是通过存储过程或者是直接传一个String sql="select * from emp where e_id=1"字符串来返回一个map。 1、如果某一列的值为空。查询这条记录时就不显示这列了。《===map中无此对应的键 2
mybatis面向接口编程，namespace属性的值对应关系
lxh123456789asd的博客
04-26 1463
背景：在Mybatis的项目中，因为使用传统的Dao开发方式可以实现所需功能，但是采用这种方式在实现类会出现大量的重复代码（缺点一），在方法中也需要指定映射文件执行语句的id，并且不能保证编写时id的正确性（在多人开发中还可能出现id重名。已经写实现类的时候会出现参数错误。这是缺点二），因此出现了使用面向接口编程的方法。在mybatis中，映射文件中的namespace是用于绑定Dao接口的，即面...
一个基于SSMM（SpringMVC+ Spring + Mybatis + Redis + Maven）的练手Demo.zip
最新发布
06-07
本项目是一个基于 Spring MVC + Spring + Mybatis + Redis + Maven 的入门级(拥有完整的登录/注册逻辑)Demo，是在SSM-Demo项目的基础上修改、调整而来，主要涉及以下几项技术及知识点： 使用SpringMVC作MVC控制器；...
个人博客系统网页实现（Spring Boot + SpringMVC + MyBatis）
09-06
知识点四：Spring MVC 框架 * Spring MVC 是一个基于 Spring 框架的 Web 框架，用于构建 Web 应用程序。 * Spring MVC 提供了模型视图控制器（MVC）模式，简化了 Web 应用程序的开发。 * 在本系统中，Spring MVC ...
spring mvc+spring+mybatis+maven的联合联系，附带数据库脚本
01-23
使用maven集成jar包的方式，搭建基于spring mvc,spring,mybatis的一个练习小demo,可帮助练习三大框架的搭建，demo设计的小知识点也比较多，登录的拦截器、aop的切面配置、国际化、以及.properties文件中敏感内容的...
spring+springmvc+mybatis项目
11-28
这里推荐几个自己写的范例项目，主要采用SSM（Spring+...范例项目的好处是简单易懂，在架构一个新的项目的时候可以直接当成脚手架来用，方便快速开发，另外项目中涉及到以及未来可能涉及到的知识点都会不断完善。
SpringMVC+MYBatis企业应用实战
04-19
本书针对每一个知识点都通过相应的程序给出了示范，所有应用范例都密切契合企业开发实际场景，例如用户权限验证、文件上传下载等都是企业开发实际功能，同时采用了目前企业流行、规范的开发架构，严格遵守Java EE...
【Spring】实例化上下文对象及加载多个配置文件
one or only的博客
11-17 715
一、实例化上下文对象 ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); Car car = (Car) ctx.getBean("car"); 几个常用的类：  ClassPathXmlApplicationContext:从类路径下的xml配置文件中加载上下文定义...
Spring总结（3）：BeanFactory和ApplicationContext
皮一下很开心的猴头
08-04 170
一、使用BeanFactory管理Bean BeanFactory采用了工厂模式，通过从XML配置文件或属性文件中读取JavaBean的定义来创建、配置和管理JavaBean。BeanFactory有很多实现类，其中，XmlBeanFactory可以通过流行的XML文件格式读取配置信息来加载JavaBean。 Resource resource=new ClassPathResource("...
第5章 MyBatis的注解开发
小猪宝宝的博客
08-30 1339
但在实际开发中，大量的XML配置文件的编写是非常繁琐的，为此，MyBatis提供了更加简便的基于注解的配置方式。
Spring Boot：@RequestParam的使用，如何接收请求，RequestMapping和GetMapping的关系。
天天向上
03-03 900
String SelectUser(@RequestParam( value="id__like",required=false ) String id__like) 需要加上( value=“id__like”,required=false）这里的id__like要和后面的id__like保持一致。如果不这样写的话，是默认必须传值的。有时候没值，前端也无法传个空的值过来时，就会出现无法进方法的情况。 ...
Spring之后处理器
qq_61313896的博客
01-03 599
Spring之后处理器
ApplicationContext接口的实现类
weixin_43183496的博客
04-22 1810
常用的实现类 1 , AnnotationConfigApplicationContext() 基于注解的实现类 (当我们使用注解配置容器时,需要使用此类来创建spring容器,它用来读取注解) 2 , ClassPathXmlApplicationContext 实际开发中都是读取类路径, 它是用于读取类路径下的配置文件 3 , FileSystemXmlApplicationC...
Spring -> 实例化上下文对象及加载多个配置文件
weixin_45808666的博客
01-04 196
1. 读取配置文件 几个常用的类： ClassPathXmlApplicationContext 从类路径下的xml配置文件中加载上下文定义. ，以classpath为当前路径 FileSystemXmlApplicationContext 读取文件系统下xml配置文件并加载 ，直接用文件系统的当前路径 与ClassPathXmlApplicationContext区别只在于查找配置文件...
java反射：根据给定类名实例化类并调用其方法
star
03-13 1万+
根据文件流读来的类名实例化类并调用方法
Java实例化类的几种方法
来者往者
01-12 1万+
最近在做一个基于Spring boot的后台管理系统 所以巩固一下自己的Java基础 这里写的是类的实例化的三种方式 1. 用new 关键字直接实例化一个对象 ExampleClass example = new ExampleClass ();2.用Java内部的反射机制 Object example = Class.forName("完整的类路径").newInstance();
怎么快速高效学习spring+springmvc+vue+mybatis？
05-03
2. 学习官方文档：官方文档是最权威的学习资源，可以帮助你快速掌握这些技术的知识点。 3. 做项目实战：做项目是最好的学习方法之一，可以帮助你将理论知识应用到实践中，提高自己的编码能力。 4. 参加培训课程：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值