select * from user where username like ‘%${value}%’ 我们在上面将原来的#{}占位符,改成了${value}。注意如果用模糊查询的这种写法,那么${value}的写 法就是固定的,不能写成其它名字。

#{}表示一个占位符号

通过#{}可以实现 preparedStatement 向占位符中设置值,自动进行 java 类型和 jdbc 类型转换,

{}可以有效防止 sql 注入。 #{}可以接收简单类型值或 pojo 属性值。 如果 parameterType 传输单个简单类型值,#{}括号中可以是 value 或其它名称。

${}表示拼接 sql 串

通过${}可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换, ${}可以接收简 单类型值或 pojo 属性值,${}括号中只能是 value。

4. <br />
<a name="654ea41e"></a>
### mybatis的一对一，一对多以及事务控制

   - <br />![](/tmp/evince-15951/image.OUJ6U0.png#id=uIdPI&originalType=binary&status=done&style=none)
   - <br />事务控制：本身也是用JDBC的setAutoCommit（）来设者事务提交方式的，我们观察上面这个图发现我们每次cud操作的时候都必须手动进行事物的提交，原因是setAutoCommit()方法,在执行时它的值被设置为 false 了,所以我们在 CUD 操作中,必须通过 sqlSession.commit()方法来执行提交操作。那我们在创建session对象的时候，设为true就可以了。`**_factory.openSession(true);_**`
   - <br />一对一的查询
      - 方式一：（推荐）用户的个实体类作为账户的子类，这样返回的时候就有了账户的那几个属性



```java
/**
*
* <p>Title: Account</p>
* <p>Description: 账户的实体类</p>
* <p>Company: http://www.itheima.com/ </p>
*/
public class Account implements Serializable {
private Integer id;
private Integer uid;
private Double money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";
}
}

/**
*
* <p>Title: AccountUser</p>
* <p>Description: 它是 account 的子类，包括了父类的属性</p>
* <p>Company: http://www.itheima.com/ </p>
*/
public class AccountUser extends Account implements Serializable {
private String username;
private String address;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return super.toString() + "
AccountUser [username=" + username + ",
address=" + address + "]";
}
}


/**
*
* <p>Title: IAccountDao</p>
* <p>Description: 账户的持久层接口</p>
* <p>Company: http://www.itheima.com/ </p>
*/
public interface IAccountDao {
/**
* 查询所有账户,同时获取账户的所属用户名称以及它的地址信息
* @return
*/
List<AccountUser> findAll();
}


映射文件的信息
<?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.dao.IAccountDao">
<!-- 配置查询所有操作-->
<select id="findAll" resultType="accountuser">
select a.*,u.username,u.address from account a,user u where a.uid =u.id;
</select>
</mapper>
注意:因为上面查询的结果中包含了账户信息同时还包含了用户信息,所以我们的返回值类型 returnType的值设置为 AccountUser 类型,这样就可以接收账户信息和用户信息了。

  - 方式二：resultMap专门定义一对一查询，思路是把User作为Account的一个属性

/**
*
* <p>Title: Account</p>
* <p>Description: 账户的实体类</p>
* <p>Company: http://www.itheima.com/ </p>
*/
public class Account implements Serializable {
private Integer id;
private Integer uid;
private Double money;
private User user;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";
}
}

/**
*
* <p>Title: IAccountDao</p>
* <p>Description: 账户的持久层接口</p>
* <p>Company: http://www.itheima.com/ </p>
*/
public interface IAccountDao {
/**
* 查询所有账户,同时获取账户的所属用户名称以及它的地址信息
* @return
*/
List<Account> findAll();
}
注意:第二种方式,将返回值改 为了 Account 类型。
因为 Account 类中包含了一个 User 类的对象,它可以封装账户所对应的用户信息。

修改映射文件
<?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.dao.IAccountDao">
<!-- 建立对应关系 -->
<resultMap type="account" id="accountMap">
    <id column="aid" property="id"/>
    <result column="uid" property="uid"/>
    <result column="money" property="money"/>
<!-- 它是用于指定从表方的引用实体属性的 -->
    <association property="user" javaType="user">
        <id column="id" property="id"/>
            <result column="username" property="username"/>
            <result column="sex" property="sex"/>
            <result column="birthday" property="birthday"/>
            <result column="address" property="address"/>
    </association>
</resultMap>

    <select id="findAll" resultMap="accountMap">
        select u.*,a.id as aid,a.uid,a.money from account a,user u where a.uid =u.id;
    </select>
</mapper>

• 一对多查询（这个时候就只能用刚才的映射关系，mybatis已经做好了和集合的关系）

/**
*
* <p>Title: User</p>
* <p>Description: 用户的实体类</p>
* <p>Company: http://www.itheima.com/ </p>
*/
public class User implements Serializable {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
private List<Account> accounts;
public List<Account> getAccounts() {
return accounts;
}
public void setAccounts(List<Account> accounts) {
this.accounts = accounts;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User [id=" + id + ", username=" + username + ", birthday=" + birthday
+ ", sex=" + sex + ", address="
+ address + "]";
}
}



<?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.dao.IUserDao">

<resultMap type="user" id="userMap">
    <id column="id" property="id"></id>
    <result column="username" property="username"/>
    <result column="address" property="address"/>
    <result column="sex" property="sex"/>
    <result column="birthday" property="birthday"/>
<!-- collection 是用于建立一对多中集合属性的对应关系 ofType 用于指定集合元素的数据类型-->
    <collection property="accounts" ofType="account">
        <id column="aid" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
    </collection>
</resultMap>
<!-- 配置查询所有操作 -->
<select id="findAll" resultMap="userMap">
select u.*,a.id as aid ,a.uid,a.money from user u left outer join account
a on u.id =a.uid
</select>
</mapper>

collection部分定义了用户关联的账户信息。表示关联查询结果集
property="accList" :关联查询的结果集存储在 User 对象的上哪个属性。
ofType="account" :指定关联查询的结果集中的对象类型即 List 中的对象类型。此处可以使用别名,也可以使用全限定名。

一级缓存和二级缓存

一级缓存

一级查询缓存是针对与SqlSession类的实例对象中，当第一次查询某个数据的时候，SqlSession类的实例对象会将该数据存入一级缓存区域，在没有收到改变该数据的请求（执行了commit操作，即增 删 改）之前，用户再次查询该数据都是从缓存中获取数据，而不是再次连接池数据库进行查询。

二级缓存

一级缓存是针对SqlSession对象的、二级缓存是针对于Mapper实例的，当多个SqlSession类的实例对象加载的是同一个Mapper文件配置的IuserDao.class（就是sqlsession.getMapper(相同的接口.class)）的时候，那么他们就共享一个Mapper缓存。

Spring

• 
  

  Spring快速入门

  • 
    1、拷贝必要的jar包到lib，或者maven导入依赖。
  • 
    2、在类路径下创建bean.xml（什么名字都可以，这是一个管理容器的配置文件）。
    • 
      ```xml 导入约束（必备的）

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

这里把切入点表达式好好说明一下 属性： id：表达式的唯一标识 expression：表达式，就是拦截那些方法。 表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数)) 修饰符可以省略，返回值可以用 ,表示可以返回任意值，包名，方法名也可以这样用，不过有几级包就有几个 ，参数列表中使用 .. 表示参数可以是任意数据类型，有参数可以使任意类型，如果使用 * 标识参数可以是任何类型，但是必须有参数。

所以一般来说我们都是对业务层的恶方法增强，所以切入点表达式都是切到业务层实现类的哪个包 execution( com.itheima.service.impl..*(..))

```java
/**
* 环绕通知
* @param pjp
* spring 框架为我们提供了一个接口:ProceedingJoinPoint,它可以作为环绕通知的方法参数。
* 在环绕通知执行时,spring 框架会为我们提供该接口的实现类对象,我们直接使用就行。
* @return
*/
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知:开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知:提交事务
commit();
}catch(Throwable e) {
//异常通知:回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知:释放资源
release();
}
return rtValue;
}

基于注解的aop配置

• 1、还是导入上面的jar包，在配置文件中导入context的名称空间，开启spring对注解的支持，和配置要扫描的包

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">


    <!--  配置spring创建容器时要扫描的包 -->
<context:component-scan base-package="com.itheima"/>
<!--  配置spring开启注解AOP的支持  -->
<aop:aspectj-autoproxy/>
    </beans>

• 2、在通知类上使用@Aspect注解他是一个切面类，然后在增强的方法上使用注解配置他是什么通知，这里用示例描述

/**
* 事务控制类
* @author 黑马程序员
* @Company http://www.ithiema.com
* @Version 1.0
*/
@Component("txManager")
@Aspect//表明当前类是一个切面类
public class TransactionManager {
//定义一个 DBAssit
@Autowired
private DBAssit dbAssit ;
}
@Before
作用:
把当前方法看成是前置通知。
属性:
value:用于指定切入点表达式,还可以指定切入点表达式的引用。
//开启事务
@Before("execution(* com.itheima.service.impl.*.*(..))")
public void beginTransaction() {
try {
dbAssit.getCurrentConnection().setAutoCommit(false);
} catch (SQLException e) {
e.printStackTrace();
}
}
@AfterReturning
作用:
把当前方法看成是后置通知。
属性:
value:用于指定切入点表达式,还可以指定切入点表达式的引用
//提交事务
@AfterReturning("execution(* com.itheima.service.impl.*.*(..))")
public void commit() {
try {
dbAssit.getCurrentConnection().commit();
} catch (SQLException e) {
e.printStackTrace();
}
}

@AfterThrowing
作用:
把当前方法看成是异常通知。
属性:
value:用于指定切入点表达式,还可以指定切入点表达式的引用
//回滚事务
@AfterThrowing("execution(* com.itheima.service.impl.*.*(..))")
public void rollback() {
try {
dbAssit.getCurrentConnection().rollback();
} catch (SQLException e) {
e.printStackTrace();
}
}

@After
作用:
把当前方法看成是最终通知。
属性:
value:用于指定切入点表达式,还可以指定切入点表达式的引用
//释放资源
@After("execution(* com.itheima.service.impl.*.*(..))")
public void release() {
try {
dbAssit.releaseConnection();
} catch (Exception e) {
e.printStackTrace();
}
}

@Around
作用:
把当前方法看成是环绕通知。
属性:
value:用于指定切入点表达式,还可以指定切入点表达式的引用。
/**
* 环绕通知
* @param pjp
* @return
*/
@Around("execution(* com.itheima.service.impl.*.*(..))")
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知:开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知:提交事务
commit();
}catch(Throwable e) {
//异常通知:回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知:释放资源
release();
}
return rtValue;
}




针对于环绕通知，这个时候也可以像上面一样直接在后面写切入点表达式，但是我这里介绍另一种方式，就是在一个方法上面使用@Pointcut注解写表达式，然后@Around在引用这个方法
@Pointcut("execution(* com.itheima.service.impl.*.*(..))")
private void pt1() {}
引用方式:
/**
* 环绕通知
* @param pjp
* @return
*/
@Around("pt1()")//注意:千万别忘了写括号
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知:开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知:提交事务
commit();
}catch(Throwable e) {
//异常通知:回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知:释放资源
release();
}
return rtValue;
}

Spring中的声明式事务控制

1、拷贝必要的jar包

2、创建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"
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/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>

（xml配置方式）重点

配置步骤：

（1）配置事务管理器

<!--  配置业务层 -->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
</bean>
<!--  配置账户的持久层 -->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
<property name="dataSource" ref="dataSource"/>
</bean>
<!--  配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/eesy"/>
<property name="username" value="root"/>
<property name="password" value="1234"/>
</bean>
<!--  spring中基于XML的声明式事务控制配置步骤
        1、配置事务管理器
        2、配置事务的通知
                此时我们需要导入事务的约束 tx名称空间和约束，同时也需要aop的
                使用tx:advice标签配置事务通知
                    属性：
                        id：给事务通知起一个唯一标识
                        transaction-manager：给事务通知提供一个事务管理器引用
        3、配置AOP中的通用切入点表达式
        4、建立事务通知和切入点表达式的对应关系
        5、配置事务的属性
               是在事务的通知tx:advice标签的内部

      -->
<!-- 第一步： 配置事务管理器  -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

<!--  第二部：配置事务的通知  引用事务管理器内的方法来管理事
                        务，该通知可以对特定的方法进行特定的事务控制 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager"> //这里引用一个事务管理器引用

<!--  第五步：配置事务的属性
                isolation：用于指定事务的隔离级别。默认值是DEFAULT，表示使用数据库的默认隔离级别。
                propagation：用于指定事务的传播行为。默认值是REQUIRED，表示一定会有事务，增删改的选择。查询方法可以选择SUPPORTS。
                read-only：用于指定事务是否只读。只有查询方法才能设置为true。默认值是false，表示读写。
                timeout：用于指定事务的超时时间，默认值是-1，表示永不超时。如果指定了数值，以秒为单位。
                rollback-for：用于指定一个异常，当产生该异常时，事务回滚，产生其他异常时，事务不回滚。没有默认值。表示任何异常都回滚。
                no-rollback-for：用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时事务回滚。没有默认值。表示任何异常都回滚。
         -->
<tx:attributes>
        <tx:method name="*" propagation="REQUIRED" read-only="false"/>//增删改操作
        <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>//查询操作，优先检索这个
</tx:attributes>

</tx:advice>

<!--  第三步：配置aop -->
<aop:config>
<!--  配置切入点表达式 -->
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"/>

<!--第四步： 建立切入点表达式和事务通知的对应关系  -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"/>
</aop:config>
</beans>

基于注解的配置方式

1、导入坐标

2、配置扫描的包，开启spring对注解的支持

<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/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!--  配置spring创建容器时要扫描的包 -->
<context:component-scan base-package="com.itheima"/>

<!--  前提：配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/eesy"/>
<property name="username" value="root"/>
<property name="password" value="1234"/>
</bean>
<!--  spring中基于注解 的声明式事务控制配置步骤
        1、配置事务管理器
        2、开启spring对注解事务的支持
        3、在需要事务支持的地方使用@Transactional注解，相当于已经告诉了aop中要拦截的方法，和事务建立起关系

      -->
<!-- 第一步： 配置事务管理器 ，并注入数据源 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>
</bean>

<!--  第二步：开启spring对注解事务的支持 -->
     <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

@Service("accountService")
//第三步：事务支持的地方使用注解
@Transactional(readOnly=true,propagation=Propagation.SUPPORTS)  //只读  事务传播行为
public class AccountServiceImpl implements IAccountService {
@Autowired
private IAccountDao accountDao;
@Override
public Account findAccountById(Integer id) {
return accountDao.findAccountById(id);
}

@Override
@Transactional(readOnly=false,propagation=Propagation.REQUIRED)
public void transfer(String sourceName, String targeName, Float money) {
//1.根据名称查询两个账户
Account source = accountDao.findAccountByName(sourceName);
Account target = accountDao.findAccountByName(targeName);

//2.修改两个账户的金额
source.setMoney(source.getMoney()-money);//转出账户减钱
target.setMoney(target.getMoney()+money);//转入账户加钱
//3.更新两个账户
accountDao.updateAccount(source);
//int i=1/0;
accountDao.updateAccount(target);

   /*该注解的属性和 xml 中的属性含义一致。该注解可以出现在接口上,类上和方法上。
出现接口上,表示该接口的所有实现类都有事务支持。
出现在类上,表示类中所有方法有事务支持
出现在方法上,表示方法有事务支持。
以上三个位置的优先级:方法>类>接口*/

SpringMVC

1、快速入门

        **1.1、导入坐标，引入开发jar包，具体坐标**

<!-- 版本锁定 -->
<properties>
<spring.version>5.0.2.RELEASE</spring.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<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>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>
</dependencies>

    **1.2  配置核心的控制器（DispatcherServlet）**

        1.2.1在web.xml中配置文件中核心控制器DispatcherServlet

<!-- SpringMVC的核心控制器 -->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 配置Servlet的初始化参数,读取springmvc的配置文件,创建spring容器 -->
<init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 配置servlet启动时加载对象，然后上面配置了初始化参数就可以读取配置文件 -->
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

**1.3 编写springmvc.xml的配置文件**（这里面就可以创建容器，配置视图解析器，开启注解）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
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"></context:component-scan>
<!-- 配置视图解析器 -->
<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/pages/"></property>    //前缀
<property name="suffix" value=".jsp"></property>    //后缀
</bean>
<!-- 配置spring开启注解mvc的支持
<mvc:annotation-driven></mvc:annotation-driven>-->
</beans>

**1.4 编写index.jsp和HelloController控制器类**

index.jsp

<body>
<h3>入门案例</h3>
<a href="${ pageContext.request.contextPath }/hello">入门案例</a>
</body>

HelloController

package cn.itcast.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* 控制器
* @author rt
*/
@Controller
public class HelloController {
/**
* 接收请求
* @return
*/
@RequestMapping(path="/hello")
public String sayHello() {
System.out.println("Hello SpringMVC!!");
return "success";
}
}

**1.5 因为在视图解析器配置的前缀是web-inf/pages  后缀是.jsp，所以我们在web-inf下面创建pages文件夹然后编写jsp页面**

<body>
<h3>入门成功!!</h3>
</body>

**1.6小结，分析执行过程**

    （1）启动Tomcat服务器的时候，因为配置了load-on-startup标签，可以加载对象，DispatchaerServlet对象便是这个servlet加载时的对象，同时给它配置了初始化参数，这个参数就是classpath:springmvc.xml，就可以加载这个配置文件了。

    （2）springmvc.xml中开启了spring对注解的支持，同时扫描了包，HelloController对象就会被加到容器中。

    （3）index.jsp发送请求的时候，请求先到DIsPatcherServlet核心控制器，然后再根据@RequestMapping注解找到具体执行的方法。

    （4）根据返回值，再根据配置的视图解析器，然后去就去指定目录下查找指定的jsp文件。

    （5）TomCat服务器渲染页面做出响应

2、请求参数的绑定

1.**绑定说明：**

        1.1 表单提交的数据都是k=v格式的

        1.2 springmvc的参数绑定过程是把表单提交的请求参数，作为控制器种方法的参数进行绑定的

        1.3 要求： 提交的表单的name要和参数的名称相同（区分大小写）

2、支持的数据类型

        2.1 基本数据类型和字符串类型

        2.2 实体类型(JavaBean)

            2.2.1 提交表单的name和JavaBean的属性名要一致

            2.2.2 如果一个javabean类中包含其他引用类型，表单的name属性就要写成：对象.属性

                        例如：address.name

        2.3  集合数据类型(List、map集合等)

                2.3.1  jsp页面的编写方式 List[0].属性

 **3、请求参数中文乱码的解决**

        在web.xml中配置spring提供的过滤器类

<!-- 配置过滤器,解决中文乱码的问题 -->
<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>

**4、自定义类型转换器（表单提交的数据都是字符串类型，spring内部会默认进行数据类型转换）**

        1、如果我们想把字符串转换成日期就可以自定义一个类型转换器

package cn.itcast.utils;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.core.convert.converter.Converter;
/**
* 把字符串转换成日期的转换器，实现接口Converter
* @author rt
*/
public class StringToDateConverter implements Converter<String, Date>{
/**
* 进行类型转换的方法
*/
public Date convert(String source) {
        // 判断
        if(source == null) {
        throw new RuntimeException("参数不能为空");
    }try {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        // 解析字符串
        Date date = df.parse(source);
        return date;
    } catch (Exception e) {
            throw new RuntimeException("类型转换错误");
    }
    }
}

    2、注册自定义类型转换器,在springmvc.xml配置文件中编写配置

<!-- 注册自定义类型转换器 -->
<bean id="conversionService"
class="org.springframework.context.support.ConversionServiceFactoryBean">
<property name="converters">
<set>
<bean class="cn.itcast.utils.StringToDateConverter"/>
</set>
</property>
</bean>
<!-- 开启Spring对MVC注解的支持 -->
<mvc:annotation-driven conversion-service="conversionService"/>

3、常用的注解

1. RequestParam注解

    1.1 作用:把请求中的指定名称的参数传递给控制器中的形参赋值

    1.2 属性

                    1.2.1 value:请求参数中的名称

                    1.2.2 required:请求参数中是否必须提供此参数,默认值是true,必须提供

    1.3 代码

/**
* 接收请求
* @return
*/
@RequestMapping(path="/hello")
public String sayHello(@RequestParam(value="username",required=false)String name) {
System.out.println("aaaa");
System.out.println(name);
return "success";
}

1. 
   RequestBody注解
   1. 作用:用于获取请求体的内容(注意:get方法不可以)
   2. 属性
   3. required:是否必须有请求体,默认值是true
   4. 代码如下

/**
* 接收请求
* @return
*/
@RequestMapping(path="/hello")
public String sayHello(@RequestBody String body) {
System.out.println("aaaa");
System.out.println(body);
return "success";
}

1. 
   PathVariable注解
   1. 
      作用:拥有绑定url中的占位符的。例如:url中有/delete/{id},{id}就是占位符
   2. 
      属性
      1. value:指定url中的占位符名称

1. 
   代码如下

<a href="user/hello/1">入门案例</a>
/**
* 接收请求
* @return
*/
@RequestMapping(path="/hello/{id}")
public String sayHello(@PathVariable(value="id") String id) {
System.out.println(id);
return "success";
}

1. 
   RequestHeader注解
   1. 作用:获取指定请求头的值
   2. 属性
      1. value:请求头的名称

1. 代码如下

@RequestMapping(path="/hello")
public String sayHello(@RequestHeader(value="Accept") String header) {
System.out.println(header);
return "success";
}

1. 
   CookieValue注解
   1. 作用:用于获取指定cookie的名称的值
   2. 属性
      1. value:cookie的名称

1. 代码

@RequestMapping(path="/hello")
public String sayHello(@CookieValue(value="JSESSIONID") String cookieValue) {
System.out.println(cookieValue);
return "success";
}

1. 
   ModelAttribute注解
   1. 
      作用
      1. 出现在方法上:表示当前方法会在控制器方法执行前线执行。
      2. 出现在参数上:获取指定的数据给参数赋值。

1. 
   应用场景

1. 
   当提交表单数据不是完整的实体数据时,保证没有提交的字段使用数据库原来的数据。
2. 
   具体的代码
   1. 
      修饰的方法有返回值 ```java /**

• 作用在方法,先执行
• @param name
• @return / @ModelAttribute public User showUser(String name) { System.out.println(“showUser执行了…”); // 模拟从数据库中查询对象 User user = new User(); user.setName(“哈哈”); user.setPassword(“123”); user.setMoney(100d); return user; } /*
• 修改用户的方法
• @param cookieValue

• @return */ @RequestMapping(path=”/updateUser”) public String updateUser(User user) { System.out.println(user); return “success”; } ```

  1. 
     修饰的方法没有返回值 ```java /**
• 作用在方法,先执行
• @param name
• @return / @ModelAttribute public void showUser(String name,Map map) { System.out.println(“showUser执行了…”); // 模拟从数据库中查询对象 User user = new User(); user.setName(“哈哈”); user.setPassword(“123”); user.setMoney(100d); map.put(“abc”, user); } /*
• 修改用户的方法
• @param cookieValue

• @return */@RequestMapping(path=”/updateUser”) public String updateUser(@ModelAttribute(value=”abc”) User user) { System.out.println(user); return “success”; } ```

  1. 
     SessionAttributes注解
     1. 作用:用于多次执行控制器方法间的参数共享
     2. 属性
        1. value:指定存入属性的名称

1. 
   代码如下

   @Controller
   @RequestMapping(path="/user")
   @SessionAttributes(value= {"username","password","age"},types=
   {String.class,Integer.class})
   // 把数据存入到session域对象中
   public class HelloController {
   /**
   * 向session中存入值
   * @return
   */
   @RequestMapping(path="/save")
   public String save(Model model) {
   System.out.println("向session域中保存数据");
   model.addAttribute("username", "root");
   model.addAttribute("password", "123");
   model.addAttribute("age", 20);
   return "success";
   }
   /**
   * 从session中获取值
   * @return
   */
   @RequestMapping(path="/find")
   public String find(ModelMap modelMap) {
   String username = (String) modelMap.get("username");
   String password = (String) modelMap.get("password");
   Integer age = (Integer) modelMap.get("age");
   System.out.println(username + " : "+password +" : "+age);
   return "success";
   }
   /**
   * 清除值
   * @return
   */
   @RequestMapping(path="/delete")
   public String delete(SessionStatus status) {status.setComplete();
   return "success";
   }
   }
   

2、Sprinmvc的响应数据和结果视图

        **2.1 返回值分类**

                2.1.1 字符串：controller  方法返回字符串是指定了逻辑视图名，通过视图解析器解析为物理视图地址

                2.1.2 void  ：这个时候可以在这个方法上面加上request和response就像原生web一样，重定向或者转发

                2.1.3  ModelAndView： 是SpringMvc为我们提供的一个对象，该对象可以作为控制器方法的返回值，然后他就会存在request中，setViewName，就是返回的那个页面，同时他是以map的形式存在，下面有示例代码。

@RequestMapping("/testReturnModelAndView")
public ModelAndView testReturnModelAndView() {
ModelAndView mv = new ModelAndView();
mv.addObject("username", "张三");
mv.setViewName("success");
return mv;
}

jsp使用el表达式获取
${requestScope.username}

        **2.2 转发和重定向**

                2.2.1: forward转发，就是springmvc提供的默认值，使用的格式

return "forward:/WEB-INF/pages/success.jsp";
//注意，这里就要像原生web一样了写真正的url

                2.2.2： Redirect重定向，使用格式

return "redirect: request.getContextPath()+"/index.jsp";
    //和原生重定向一样不能访问web-inf下的目录

        **2.3 ResponseBody响应json数据**

                作用:    该注解用于将 Controller 的方法返回的对象,通过 HttpMessageConverter 接口转换为指定格式的

                                数据如:json,xml 等,通过 Response 响应给客户端。

                在使用之前要导入三个jar包

                    ![](/home/djc/.config/Typora/typora-user-images/image-20201202195845413.png#id=R17g6&originalType=binary&status=done&style=none)

            下面通过代码更好的展示

jsp 中的代码:
<script
type="text/javascript"
src="${pageContext.request.contextPath}/js/jquery.min.js"></script>
<script type="text/javascript">
$(function(){
$("#testJson").click(function(){
$.ajax({
    type:"post",
    url:"${pageContext.request.contextPath}/testResponseJson",
    contentType:"application/json;charset=utf-8",
    data:'{"id":1,"name":"test","money":999.0}',
    dataType:"json",

    success:function(data){
            alert(data);
}
});
});
})
</script>
<!-- 测试异步请求 -->
<input type="button" value=" 测试 ajax 请求 json 和响应 json" id="testJson"/>

控制器中的代码:
/**
* 响应 json 数据的控制器
* @author 黑马程序员
* @Company http://www.ithiema.com
* @Version 1.0
*/
@Controller("jsonController")
public class JsonController {
/**
* 测试响应 json 数据
*/
@RequestMapping("/testResponseJson")
public @ResponseBody Account testResponseJson(@RequestBody Account account) {
System.out.println("异步请求:"+account);
return account;
}
}

运行结果如图：

                            ![](/home/djc/.config/Typora/typora-user-images/image-20201202195953770.png#id=gTKWQ&originalType=binary&status=done&style=none)

3、SpringMvc中的异常处理

        1、处理的思路：dao、service、controller出现异常都往上跑，最后由springmvc前端控制器交给异常处理器进行异常处理。

        2、这里实现一个异常处理

                2.1 编写一个异常类和错误页面

异常类
/**
* 自定义异常
* @author 黑马程序员
* @Company http://www.ithiema.com
* @Version 1.0
*/
public class CustomException extends Exception {
    private String message;
    public CustomException(String message) {
        this.message = message;
    }
    public String getMessage() {
    return message;
    }
}

                    jsp页面

jsp 页面:
<%@
page
language="java"
contentType="text/html;
charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE
html
PUBLIC
"-//W3C//DTD
HTML
4.01
Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>执行失败</title>
</head>
<body>
执行失败!
        ${message }
</body>
</html>

                2.2 自定义异常处理器

/**
* 自定义异常处理器
* @author 黑马程序员
* @Company http://www.ithiema.com
* @Version 1.0
*/
public class CustomExceptionResolver implements HandlerExceptionResolver {
        @Override
        public ModelAndView resolveException(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex) {
        ex.printStackTrace();
        CustomException customException = null;
        //如果抛出的是系统自定义异常则直接转换
        if(ex instanceof CustomException){
            customException = (CustomException)ex;
        }else{
            //如果抛出的不是系统自定义异常则重新构造一个系统错误异常。
            customException = new CustomException("系统错误,请与系统管理 员联系!");
        }
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("message", customException.getMessage());
            modelAndView.setViewName("error");
            return modelAndView;//返回error这个页面
        }
}

                2.3 配置异常处理器

<!-- 配置自定义异常处理器 -->
<bean id="handlerExceptionResolver"
class="com.itheima.exception.CustomExceptionResolver"/>

运行结果：

4、SpringMvc中的拦截器

        **1、作用：**

                他是springmvc独有的，只有使用了Springmvc才能使用。它只会拦截访问的控制器的方法，如果访问的jsp、html、css、js这些静态资源的时候他不会拦截。（和过滤器很像）

        **2、自定义拦截器**（这里的每个方法具体说明了就是再说拦截器链的放行的顺序）

                2.1 编写一个普通类实现HandlerInterceptor接口

/**
* 自定义拦截器
* @author 黑马程序员
* @Company http://www.ithiema.com
* @Version 1.0
*/
public class HandlerInterceptorDemo1 implements HandlerInterceptor {

    /*
        按拦截器定义的顺序调用
        只要配置了都会调用
        决定是否调用其他拦截器或者直接去控制器层法
    */
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponseresponse, Object handler) throws Exception {
        System.out.println("preHandle 拦截器拦截了");
        return true;
}

    /*
        按拦截器定义逆序调用
        在拦截器链内所有拦截器成功后调用
        在控制层处理完请求后，这里主要是对request请求进行处理，在DispatcherServlet向客户端返回响应钱被调用
    */
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle 方法执行了");
}

   /*
           按拦截器定义逆序调用
           只有当前的这个了preHandle返回true才会调用
           在DispatcherServlet完全处理完请求后背盗用，一般处理资源清理的操作
   */
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception {
        System.out.println("afterCompletion 方法执行了");
}
}

多个拦截器的执行顺序：

                2.2 配置拦截器

<!-- 配置拦截器 -->
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>        <!-- 表示对所有的访问都拦截-->
<bean id="handlerInterceptorDemo1"
class="com.itheima.web.interceptor.HandlerInterceptorDemo1"></bean>
</mvc:interceptor>
</mvc:interceptors>

                运行结果：

4、SSM整合框架 （xml+注解）

**1、整合的思路：**

    （1）先搭建整合的环境（就是导入坐标，需要的jar包）

    （2）先把Spring的配置搭建完成

    （3）Spring整合SpringMvc

    （4）Spring整合Mybatis

**2、创建Maven的工程，并导入相关的依赖**

    （1）创建ssm_parent父工程(打包方式选择pom,必须的)

    （2）创建ssm_web子模块(打包方式是war包

    （3）创建ssm_service子模块(打包方式是jar包

    （4）创建ssm_dao子模块(打包方式是jar包

    （5）创建ssm_domain子模块(打包方式是jar包

    （6）web依赖于service,service依赖于dao,dao依赖于domain

    （7）在ssm_parent的pom.xml文件中引入坐标依赖

<properties>
<spring.version>5.0.2.RELEASE</spring.version>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<mysql.version>5.1.6</mysql.version>
<mybatis.version>3.4.5</mybatis.version>
</properties>
<dependencies><!-- spring -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</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-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>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version><scope>compile</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- log start -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency><dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
</dependencies>
<build>
<finalName>ssm</finalName>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
<showWarnings>true</showWarnings>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>

**3、搭建Spring框架**

        （1）在ssm_web项目中创建applicationContext.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.xsdhttp://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 开启注解扫描,要扫描的是service和dao层的注解,要忽略web层注解,因为web层让SpringMVC框架
去管理 -->
<context:component-scan base-package="cn.itcast">
<!-- 配置要忽略的注解 -->
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
</beans>

4、搭建SpringMvc框架

（1）在web.xml中配置Dispatcher前端控制器

<!-- 配置前端控制器:服务器启动必须加载,需要加载springmvc.xml配置文件 -->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 配置初始化参数,创建完DispatcherServlet对象,加载springmvc.xml配置文件 -->
<init-param><param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 服务器启动的时候,让DispatcherServlet对象创建 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

<!-- 配置解决中文乱码的过滤器 -->
<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>

    （2）创建SpringMvc.xml并进行相关配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
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">
<!-- 扫描controller的注解,别的不扫描 -->
<context:component-scan base-package="cn.itcast">
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- 配置视图解析器 -->
<bean id="viewResolver"class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- JSP文件所在的目录 -->
<property name="prefix" value="/WEB-INF/pages/" />
<!-- 文件的后缀名 -->
<property name="suffix" value=".jsp" />
</bean>
<!-- 设置静态资源不过滤 -->
<mvc:resources location="/css/" mapping="/css/**" />
<mvc:resources location="/images/" mapping="/images/**" />
<mvc:resources location="/js/" mapping="/js/**" />
<!-- 开启对SpringMVC注解的支持 -->
<mvc:annotation-driven />
</beans>

5、Spring整合SpringMvc框架

（1）怎么知道我们整合成功了，只要我们controller成功调用service对象的方法就可以了（说明注入成功了）

（2）当我们项目启动的时候,web.xml已经会去访问springmvc.xml了，这个时候我们我们其实只差ApplicationContext.xml了，我们想办法加载他就可以了。

在web.xml中配置ContextLoaderListener监听器(该监听器只能加载WEB-INF目录下的applicationContext.xml的配置文
件)。

<!-- 配置Spring的监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-
class>
</listener>
<!-- 配置加载类路径的配置文件 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>

6、Spring整合MyBatis框架（在Application.xml就可以了）

（1）我们其实只需要把SqlMapConfig.xml的内容配置到Application.xml就可以了

<!-- 配置C3P0的连接池对象 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql:///ssm" />
<property name="username" value="root" />
<property name="password" value="root" />
</bean>
<!-- 配置SqlSession的工厂，可以创建一个真正的sqlsession ，然后sqlsession就可以创建代理对象存到ioc容器中-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
</bean>
<!-- 配置扫描dao的包  接口 将Mapper接口生成代理注入到Spring-->
<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="cn.itcast.dao"/>
</bean>

7、最后的applicationContext,xml的内容

<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">
<!-- 开启注解的扫描，希望处理service和dao，controller不需要Spring框架去处理 -->
<context:component-scan base-package="cn.itcast">
<!-- 配置哪些注解不扫描 -->
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- Spring整合MyBatis框架 -->
<!-- 配置连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql:///ssm"/>
<property name="user" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- 配置SqlSessionFactory工厂 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置AccountDao接口所在包 -->
<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="cn.itcast.dao"/>
</bean>

</beans>

springmvc.xml的内容

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context" 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">
<!-- 开启注解扫描，只扫描Controller注解 -->
<context:component-scan base-package="cn.itcast">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- 配置的视图解析器对象 -->
<bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/pages/"/>
<property name="suffix" value=".jsp"/>
</bean>
<!-- 过滤静态资源 -->
<mvc:resources location="/css/" mapping="/css/**"/>
<mvc:resources location="/images/" mapping="/images/**"/>
<mvc:resources location="/js/" mapping="/js/**"/>
<!-- 开启SpringMVC注解的支持 -->
<mvc:annotation-driven/>
</beans>