ssm整合

session注销： session.invalidate();




redis缓冲服务器
配置环境：将redis路径放到环境变量中
  运行cmd，cd空格redis路径
  盘符：
  进入redis，输入redis-server.exe redis.windows.conf


  https://www.cnblogs.com/herry52/p/5938902.html
  https://www.cnblogs.com/edisonfeng/p/3571870.html


打开redis-cli.exe，键值对存储 语法 set key value
get key
save

####1.初始MyBatis####
  ##1.1配置相关文件
在resources文件下创建db.properties文件
     1.db.properties的配置信息如下 导入相关jar包
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/easybuy
user=root
password=root
2.mybatis-config.xml的配置信息如下
    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 数据库连接配置 -->
<properties resource="db.properties"/>
<!-- 给entity包下的实体类 -->
<typeAliases>
<package name="entity"/>
</typeAliases>

<environments default="mysql_development">
<environment id="mysql_development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${user}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<!-- 导入mapper -->
<mapper resource="mapping/newsMapper.xml"/>
</mappers>
</configuration>
   3.导入log4j.properties
   4.在src下创建mapping包，创建相关实体类的xml配置文件
     例如：
<?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="cj">
<select id="findNewsById" parameterType="int" resultType="entity.News">
<!-- jdbc:?  hibernate: :z :x mybatis: #{xx} -->
select * from easybuy_news where id=#{id}; 
</select>
</mapper>
5.在创建一个测试
package test;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import entity.News;
public class TestMyBatis {
public static void main(String[] args) {
//先读取数据源信息
try {
InputStream in=Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(in);
//获取连接
SqlSession sqlSession=factory.openSession();
//这个方法直接帮助我们获取查询的结果对象(sql,params,class)
News news= sqlSession.selectOne("cj.findNewsById",531);
System.out.println(news);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
####1.2初始MyBatis####
  ##1.2.1MyBatis框架以及ORM##
1.简介
MyBatis是一个开源的数据持久层框架,它内部封装了JDBC访问数据库的操作，支持普通的SQL查询，存储过程与高级映射
2.什么是ORM
即对象/关系映射，是一种数据持久化技术，它在对象模型和关系型数据库之间简历起对应关系，并提供一种机制，通过javaBean
对象去操作数据库表中的数据
  ##1.2.2MyBatis环境搭建
官方网址：http://mybatis.org,可以下载最新Release版本的MyBatis，其他Release版本的MyBatis的jar文件都可以从官方网址上下载得到
1.部署jar文件
2.创建MyBatis核心配置文件configuration.xml，一般将此文件名命名为"mybatis-config.xml"；
4.创建持久化类POJO和SQL映射文件
持久化类是指其实例状态需要被MyBatis持久化到数据库中的类，在应用的设计中，持久化类通常对应需求中的业务实体。MyBatis一般采用POJO变成模型来实现持久
化类，与POJO类配合完成持久化工作。
5.创建映射文件
完成POJO的映射，该文件也是一个XML文件，命名为UserMapper.xml，用于存储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">
<mapper namespace="cj">
<select id="findNewsById" parameterType="int" resultType="News">
<!-- jdbc:?  hibernate: :z :x mybatis: #{xx} -->
select * from easybuy_news where id=#{id}; 
</select>
<select id="findAll" resultType="entity.News">
select * from easybuy_news;
</select>
<delete id="deleteNewsById" parameterType="int">
delete from easybuy_news where id=#{id};
</delete>
<delete id="deleteNews" parameterType="map">
delete from easybuy_news where id in(#{key1},#{key2});
</delete>
<insert id="insertNews" parameterType="entity.News">
insert into easybuy_news(title,content,createTime) values(#{title},#{content},#{createTime});
</insert>
<select id="findOne" parameterType="String" resultType="News">
select * from easybuy_news where title=#{title};
</select>
</mapper>
                6.创建测试类
1）读取全局配置文件:mybatis-config.xml
String resource="mybatis-config.xml";
2)获取Mybatis-config.xml的输入流
InputStream in=Resources.getResourceAsStream(resources);
3)创建SqlSessionFactory对象，此对象可以完成对配置文件的读取
SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(in);
4)创建SqlSession对象，此对象的作用是调用mapper文件进行数据操作，需要将mapper文件引入到mybatis-config.xml中才可以起效
SqlSession sqlSession=factory.openSession();
//MyBatis一般通过mapper文件的namespace和子元素的id来找到相应的SQL，从而执行查询操作
sqlSession.selectOne("mapper文件中的id");
//事务提交到数据库中
sqlsession.commit();
5)关闭SqlSession
sqlSession.close();
####1.3MyBatis框架的优缺点以及其适用场合####
1.MyBatis的优点
1）与JDBC相比，减少了50%以上的代码量
2）MyBatis是最简单的持久化框架，小巧并且简单易学
3）MyBatis相当灵活，不会对应用程序或者数据库的现有设计强加任何影响，Sql写在XML里，从程序代码中彻底分离，降低耦合度，便于统一管理和优化，并可重用
4）提供XML标签，支持编写动态SQL语句
5）提供映射标签，支持对象与数据库的ORM字段关系映射
2.MyBatis的缺点
1）SQL语句的编写工作量较大，对开发人员编写SQL语句的功底有一定要求
2）SQL语句依赖于数据库，导致数据库移植性差，不能随意更换数据库
3.适用的场合
MyBatis专注于SQL本身，是一个足够灵活的DAO层解决方案，对性能的要求很高，或者需求变化较多的项目，如互联网项目。
  ##1.4使用mapper接口操作##
1.在映射文件中，namespace必须为对应包下的接口文件
2.id必须是接口文件的方法名
3.接口 接口对象=生成sqlSession.getMapper(接口.class)
4.使用接口对象.映射文件中id；直接使用接口对象进行操作
例：接口：package Dao;
import java.util.List;
import entity.News;
public interface INewsDao {
int insertNews(News news);
int updateNews(News news);
int deleteNews(int id);
News findNews(String title);
List<News> findAll();
//分页
List<News> findPageNews(int startIndex,int pageSize);
}
映射文件：<?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="Dao.INewsDao">
<select id="findPageNews" resultType="News">
select * from easybuy_news limit #{0},#{1};
</select>
</mapper>
测试：SqlSession sqlSession=DbUtil.getSqlSession();
INewsDao newsDao=sqlSession.getMapper(INewsDao.class);
List<News> list=newsDao.findPageNews(0, 1);
5.描述映射关系，在映射文件中使用<select id="findOrderById" resultMap="orderMap">//描述映射关系
select * from easybuy_order where id=#{id};
</select>
//描述映射信息，到底哪个字段名对应哪个属性名
<resultMap type="Order" id="orderMap">
<result property="id" column="id"/>
<result property="name" column="loginName"/> //在实体类中的属性名为：name，而数据库中为loginName，
<result property="userAddress" column="userAddress"/>
<result property="createTime" column="createTime"/>
</resultMap>
6.通过类映射数据库表中的数据，可以在类中使用自定义实体类在去映射到另一个表的数据：
IdentityDao identityDao=sqlSession.getMapper(IdentityDao.class);
System.out.println(identityDao.findIdentityById(2));


    7.映射 <select id="findRole" resultMap="role_userMapper" parameterType="String">
select *,r.id as rid,u.id as uid from smbms_role as r,smbms_user as u
where r.id=u.userRole
and roleName=#{roleName};
</select>
<resultMap type="role" id="role_userMapper">
<id column="rid" property="id"/>
<collection property="users" ofType="user" resultMap="dao.IUserDao.user_mapper">
</collection>
</resultMap>

id对应表的主键
   associatioin对应级联操作，一对一映射
   collection 一对多映射   property=users,oftype=user
   
   
   动态sql
   <!-- 动态添加 -->
<insert id="insert_user" parameterType="User">
<!-- 可将插入的主键输出 -->
<selectKey keyProperty="id" order="AFTER" resultType="int">
select last_insert_id();
</selectKey>
insert into smbms_user(<include refid="key"/>) values(<include refid="value"/>);
</insert>
<sql id="key">
<trim suffixOverrides=",">
<if test="id!=null">id,</if>
<if test="userCode!=null">userCode,</if>
</trim>
</sql>
<sql id="value">
<trim suffixOverrides=",">
<if test="id!=null">#{id}</if>
<if test="userCode!=null">#{userCode},</if>
</trim>
</sql>
   
   trim标签可以去除一些多余的符号如","
   
   
   <!-- 动态删除 -->
<delete id="delete_user">
delete from smbms_user where id in
<foreach collection="list" item="id" open="(" close=")" separator=",">
#{id}
</foreach>
</delete>


   
   <!-- settings是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。 -->  
    <settings>  
        <!-- 该配置影响的所有映射器中配置的缓存的全局开关。默认值true -->  
      <setting name="cacheEnabled" value="true"/>  
      <!--延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。默认值false  -->  
      <setting name="lazyLoadingEnabled" value="true"/>  
        <!-- 是否允许单一语句返回多结果集（需要兼容驱动）。 默认值true -->  
      <setting name="multipleResultSetsEnabled" value="true"/>  
      <!-- 使用列标签代替列名。不同的驱动在这方面会有不同的表现， 具体可参考相关驱动文档或通过测试这两种不同的模式来观察所用驱动的结果。默认值true -->  
      <setting name="useColumnLabel" value="true"/>  
      <!-- 允许 JDBC 支持自动生成主键，需要驱动兼容。 如果设置为 true 则这个设置强制使用自动生成主键，尽管一些驱动不能兼容但仍可正常工作（比如 Derby）。 默认值false  -->  
      <setting name="useGeneratedKeys" value="false"/>  
     <!--  指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示取消自动映射；PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。 FULL 会自动映射任意复杂的结果集（无论是否嵌套）。 -->   
     <!-- 默认值PARTIAL -->  
      <setting name="autoMappingBehavior" value="PARTIAL"/>  
        
      <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>  
     <!--  配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。默认SIMPLE  -->  
      <setting name="defaultExecutorType" value="SIMPLE"/>  
      <!-- 设置超时时间，它决定驱动等待数据库响应的秒数。 -->  
      <setting name="defaultStatementTimeout" value="25"/>  
        
      <setting name="defaultFetchSize" value="100"/>  
      <!-- 允许在嵌套语句中使用分页（RowBounds）默认值False -->  
      <setting name="safeRowBoundsEnabled" value="false"/>  
      <!-- 是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。  默认false -->  
      <setting name="mapUnderscoreToCamelCase" value="false"/>  
      <!-- MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。  
             默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。  
            若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。  -->  
      <setting name="localCacheScope" value="SESSION"/>  
      <!-- 当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。 某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。  -->  
      <setting name="jdbcTypeForNull" value="OTHER"/>  
    <!--   指定哪个对象的方法触发一次延迟加载。  -->  
      <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>  
    </settings>


延迟加载：
<setting name="lazyLoadingEnabled" value="true"/>  
<setting name="aggressiveLazyLoading" value="false"/>
 
需要时加载，不需要时可以不加载
<!-- 延迟加载 -->
<select id="find" parameterType="int" resultMap="findMap">
select * from smbms_user where id=#{id};
</select>
<resultMap type="user" id="findMap">
<id property="id" column="id"/>
<association property="role" select="findR" column="userRole"></association>
</resultMap>
<select id="findR" parameterType="int" resultType="Role">
select * from smbms_role where id=#{id};
</select>
   例题：    
<select id="findBill" resultMap="shop_map" parameterType="map">
select sb.billCode,sb.productName,sp.proCode,sp.proName,sp.proContact,sp.proPhone,sb.totalprice,sb.isPayment 
from smbms_bill as sb  inner JOIN smbms_provider as sp on sb.providerId=sp.id 
<if test="key1 !=null">
  and sb.productName LIKE '%${key1}%'
</if>
<if test="key2 !=null">
and isPayment=#{key2}
</if>
<if test="key3 !=null">
and providerId=#{key3};
</if>
</select>
<resultMap type="Bill" id="shop_map">
<id column="sb.id" property="id"/>
<association property="provider" resultMap="shop_privider"></association>
</resultMap>
<resultMap type="Provider" id="shop_privider">
<id column="sp.id" property="id"/>
</resultMap>
使用redis：https://www.cnblogs.com/edisonfeng/p/3571870.html   

and使用where标签自动去重
逗号使用trim标签自动去重

maven命令：进入workspace的maven项目
mvn compile编译
mvn package打war包
mvn clean清除
mvn test测试
mvn install部署
   
   
####spring####
1.IOC和DI 名词解释；理解解耦，分层，工厂
2.AOP 名次解释；理解切面编程思想，动态代理
3.Spring声明式事务
4.Spring和myBatis整合

<?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-4.0.xsd   
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd   
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd   
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">  


<bean id="dog1" class="entity.Dog"></bean>
<bean id="dog2" factory-method="getInstance" class="factory.DogFactory"></bean>
<!-- 开启spring注解扫描 -->
<!-- 任何一个类上面只要有@Component,name是类型的驼峰写法 -->
<context:annotation-config></context:annotation-config>
<context:component-scan base-package="entity,dao,*"></context:component-scan>
<bean id="dog3" class="entity.Dog"><!-- name和ID是有等效的，id唯一，那么重复的话会覆盖前面的 -->
<property name="id" value="1"></property>
<property name="name" value="哈哈"></property>
<property name="strs">
<list>
<value>哈哈</value>
<value>2</value>
<value>3</value>
</list>
</property>
</bean>
<!-- 通过有参构造方式注入属性 -->
<bean name="dog4" class="entity.Dog">
<constructor-arg name="id" index="0" value="4"></constructor-arg>
<constructor-arg name="name" index="1" value="哈哈"></constructor-arg>
</bean>




</beans> 
配置文件applicationContext.xml
<!-- scope 配置 spring容器给你创建的对象是单例还是多例 -->
  <!-- 默认scope="singleton"(创建时机初始化的时候,lazy-init是否按需加载)   
  prototype多例（创建时机getbean的时候） -->
  <bean id="dogDao" class="dao.impl.DogDaoImplMysql" scope="singleton"  lazy-init="true">
  </bean>
  <bean id="dogService" class="service.DogService">
<!-- 给dogService加属性,name是属性名,value是属性值 ,ref代表属性值是spring容器当中的某个对象 -->
<!-- 依赖注入，你属性的值不再自己在类当中new，而是在这边配置，让spring给你注入 -->
<property name="dogDao" ref="dogDao"></property>
  </bean>

  <bean id="dog" class="entity.Dog" scope="prototype">
<property name="id" value="2"></property>
<property name="name" value="哈哈"></property>
  </bean>
 
  <bean id="str" class="java.lang.String">

  </bean>
   <bean id="dog1" class="entity.Dog"></bean>
<bean id="dog2" factory-method="getInstance" class="factory.DogFactory"></bean>
   注解：@Component
   <!-- 使用4.0以上的版本 -->
   
   IOC(控制反转)："控制"就是指对对象的创建、维护、销毁、等生命周期的控制。这个过程一般是由我们的程序去主动的
   控制，如使用new关键字去创建一个对象(创建)，在使用过程中保持引用(维护),在失去全部引用后由GC去回收对象(销毁)。
   "反转"就是指对对象的创建，维护，销毁等生命周期的控制由程序控制改为由IOC容器控制，需要某个对象时就直接通过名字去IOC容器中获取
   就是将组件对象的控制权从代码本身转移到外部容器，解决了代码的耦合度，更利于代码的扩展。
   
   DI(依赖注入):是IOC的一种重要实现，一个对象的创建往往会涉及到其他对象的创建，比如一个对象A的成员变量持有另一个对象B的引用，
   这就是依赖，A依赖于B，IOC机制既然负责了对象的创建，那么这个依赖关系也要由IOC容器负责，负责的方式就是依赖注入，通过将依赖关系写如配置文件，
   然后在创建对象的时，由IOC容器注入依赖的对象，如在创建对象A时，检查到有依赖关系，IOC容器就把A依赖的对象B创建后注入到A中，（通过反射机制实现）
   然后把A返回给对象请求者，完成工作
   
   IOC的意义：IOC并没有实现更多的功能，但它的存在使我们不需要很多的代码，不需要考虑对象间复杂的耦合关系就能从IOC容器中获取合适的对象，并且提供了对对象
   的可靠的管理，极大地降低了开发的负责性
   
   
   切入点表达式
execution(访问权限修饰符? 返回类型 ? 方法匹配(参数匹配))
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.*.*(..))" id="pt"/>-->

<!-- 【拦截所有public方法】 -->
<!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->

<!-- 【拦截所有save开头的方法 】 -->
<!--<aop:pointcut expression="execution(* save*(..))" id="pt"/>-->

<!-- 【拦截指定类的指定方法, 拦截时候一定要定位到方法】 -->
<!--<aop:pointcut expression="execution(public * cn.itcast.g_pointcut.OrderDao.save(..))" id="pt"/>-->

<!-- 【拦截指定类的所有方法】 -->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.*(..))" id="pt"/>-->

<!-- 【拦截指定包，以及其自包下所有类的所有方法】 ..两个点代表及其子包，自后一个星代表方法 -->
<!--<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>-->

<!-- 【多个表达式】 -->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) || execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) or execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
<!-- 下面2个且关系的，没有意义 -->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) &amp;&amp; execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) and execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

<!-- 【取非值】 -->
<!--<aop:pointcut expression="!execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
<aop:pointcut expression=" not execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>

添加事务自动回滚
<!-- 开启注解 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<!-- 配置事务管理器 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据库连接池 -->
<property name="dataSource" ref="dataSource" />
</bean>
<!-- 配置基于注解的声明式事务 -->
<tx:annotation-driven transaction-manager="transactionManager" />

给方法或者service层的类添加注解@Transactional
当使用aop去增强时，需要将可能出现的异常抛给control层去处理，事务才会回滚
例题：AOP
@Component //控制反转
@Aspect //切面
public class LogAspect {
private Logger log=Logger.getLogger(LogAspect.class);
@Around(value="execution(public * service.*.*(..))")//点到方法
public Object aroundAdvice(ProceedingJoinPoint pjp)throws Throwable {//必须要有返回值,当需要事务回滚时抛出异常
Object obj=null;
log.info("前置增强");


//执行目标方法
obj=pjp.proceed();

log.info("后置增强");
return obj;
}

}

补充2： 事务特性ACID 原子性，一致性，隔离性，持久性
        事务隔离级别：
Read uncommitted  脏读: 一个事务读到了另一个事务未提交的数据。
         Read committed 不可重复读: 一个事务读到了另一个事务已经提交的数据(update) 导致一个事务中多次查询结果不一致。
         Read Repeatable 虚读: 一个事务读到了另一个事务已经提交的数据(insert) 到最后一个事务多次查询结果不一致。
         Serizable
事务的传播特性:
PROPAGATION_REQUIRED：支持当前的事务，如果不存在就创建一个。如果A有事务，B使用A的事务,如果A没有事务，B就开启一个新的事务(保证A和B在同一个事务中)。
PROPAGATION_SUPPORTS：支持当前事务，如果不存在就不使用事务。A、B：如果A有事务，B使用A的事务，如果A没有事务，B就不使用事务。
PROPAGATION_MANDATORY：支持当前的事务，如果不存在就会抛出异常。A、B: 如果A有事务,B使用A的事务,如果A没有事务则抛出异常。
PROPAGATION_REQUIRES_NEW：如果有事务存在，则挂起当前事务，创建一个新的事务。A、B: 如果A有事务，B将A的事务挂起,重新创建一个新的事务(保证A和B不在同一个事务中)。
PROPAGATION_NOT_SUPPORTED：以非事务的方式运行，如果有事务存在，挂起当前的事务。A、B:非事务的方式运行,A有事务就会挂起当前的事务。
PROPAGATION_NEVER：以非事务的方式运行，如果有事务存在则抛出异常。 
PROPAGATION_NESTED：如果当前事务存在，则嵌套事务执行。它基于SavePoint(保存点)技术。A、B: A有事务,A执行事务之后的内容保存到SavePoint，若B事务有异常，由自己设置事务提交还是回滚。




①.介绍springmvc的强大所在


②.第一个springmvc的程序


③.springmvc的流程，名词


④.换一种手法感受流程各个角色的意义
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="testSecond.action">second</prop>
<prop key="/zy.action">second</prop>
</props>
</property>
⑤.再换一种手法感受流程意义。使用注解手法
<mvc:annotation-driven /> 
@Controller
@RequestMapping()


讲解返回ModelAndView，返回String，无返回值情况。


如何才能重定向


⑥.参数绑定
--1.默认参数：request,response,session,model


--2.自动入参@RequestParam;讲解里面参数
自动封装对象;
双对象，同属性;编写‘’
复杂对象:属性参照struts2写法
日期类型@DateTimeFormat(pattern="yyyy-MM-dd")
6.修改前端控制器映射路径为/;讲解区别


<mvc:default-servlet-handler/>


7.




③注释:
DispatcherServlet：前端控制器，由SpringMVC提供。
HandlerMapping：处理器映射器，由SpringMVC提供。
HandlerAdapter：处理器适配器，由SpringMVC提供。
Handler：处理器，需要程序员开发。
ViewResolver：视图解析器，由SpringMVC提供。
view：真正的视图页面，由程序员编写。


web.xml的配置：
<!-- 定义MVC的前端控制器 -->
  <servlet>
  <servlet-name>dispatcherServlet</servlet-name> <!-- 随便取个名字 -->
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!-- 这个servlet的类路径 -->
  <!-- 加载所有的spring配置文件 -->
  <init-param><!-- 给spring配置初始化参数 -->
   <param-name>contextConfigLocation</param-name>
   <param-value>classpath:spring-*.xml</param-value>


  </init-param>
  <!-- servket随着服务器启动就初始化 -->
  <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
  <servlet-name>dispatcherServlet</servlet-name><!-- 上面的名字 -->
  <url-pattern>*.action</url-pattern> <!-- 映射路径 -->
  </servlet-mapping>
  
  使用springMVC传参中可以有对象
  @RequestMapping(value="/pay")
//public String payControl(Model model,@RequestParam(value="id1",required=false)int id1,@RequestParam(value="id2",required=false)int id2,int money) {
// try {
// AccountService.pay(id1, id2, money);
// model.addAttribute("message","转账成功");
// } catch (Exception e) {
// // TODO Auto-generated catch block
// model.addAttribute("message", e.getMessage());
// e.printStackTrace();
// }
// return "/index.jsp";
//}
//通过requestMapping映射对象
public String payControl(Model model,PayForm payForm) {//payForm对象中的属性必须和提交的信息的name属性一致
try {
AccountService.pay(payForm.getId1(), payForm.getId2(), payForm.getMoney());
model.addAttribute("message","转账成功");
} catch (Exception e) {
// TODO Auto-generated catch block
model.addAttribute("message", e.getMessage());
e.printStackTrace();
}
return "/index.jsp";
}
//根据视图自动给SptringMVC入参<!-- 对象级联入参 -->
<form action="/ssm/person/test1" method="post">
姓名：<input name="name" type="text">
帐号ID：<input name="account.id" type="text">
帐号金额:<input name="account.money" type="text">
<input type="submit" value="提交">
</form>

@ModelAttribute("person")=request.setAttribute("person",person);//将形参的person对象传到request域中

在spring-web里添加视图解析
<!-- 视图解析器 -->  
     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <!-- <property name="prefix" value="/WEB-INF/jsp/"></property> -->
  <property name="suffix" value=".jsp"></property>
  </bean>
    
@NumberFormat(pattern="#,###.##")
private double user_salary; //员工工资
@DateTimeFormat(pattern="yyyy-MM-dd")
private Date user_brithday; //员工生日




使用SpringMVC的默认存在的json，导入jackson-core-asl-1.9.13.jar，jackson-mapper-asl-1.9.13.jar
@RequestMapping(value="/test3")
public @ResponseBody Object test3(String name ,HttpServletResponse response) throws IOException {
System.out.println(name);
Person person=new Person();
person.setName(name);
return person;
}



使用SpringMVC上传文件：导入commons-io-2.4.jar和commons-fileupload-1.3.1.jar
在Spring-web中输入

<!-- 文件上传 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="defaultEncoding" value="UTF-8"></property>
<property name="maxUploadSize" value="5242880"></property>

</bean>
view代码：
<form action="/ssm/person/test4" method="post" enctype="multipart/form-data">
名字：<input name="name1">
<input name="file" type="file">
<input type="submit" value="提交文件">
</form>
控制层代码：
@RequestMapping(value="/test4")
 public String upLoad(String name1,MultipartFile file) throws IllegalStateException, IOException {
if(!file.isEmpty()) {
System.out.println("desc");
file.transferTo(new File("d:\\"+file.getOriginalFilename()));
}
return "/index";
 }

转发：return "路径"; 或者return "forward:路径";
重定向：return"redirect:路径";

#####SpringMVC的异常处理
1.实现HandlerException接口，重写resolveException方法，添加注解@Component或者@ControllerAdvice，@ExceptionHandler，添加注解扫描
2.会处理所有的异常
####拦截器
1.实现HandlerInterceptor接口，在spring-web中添加
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="包名.类名"></bean>
</mvc:interceptor>        
</mvc:interceptors>
####RESTful
理解RESTful
@RequestMapping(value="{id}",method=RequestMethod.GET)
public String get(@PathVariable("id")Integer id) {
System.out.println(id);
return "/index";
}
@RequestMapping(value="{id}",method=RequestMethod.DELETE)
public String delete(@PathVariable("id")Integer id) {
System.out.println(id);
return "/index";
}
jsp：
  <form action="/ssm/person/1" method="get">
<input type="submit" value="获取">
</form>

<form action="/ssm/person/2" method="delete">
<input type="submit" value="删除">
</form>

在web.xml中配置
<!-- 使过滤器处理put和delete -->
   <filter>
  <filter-name>HiddenHttpMethodFilter</filter-name>
  <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  </filter>
  <filter-mapping>
  <filter-name>HiddenHttpMethodFilter</filter-name>
  <url-pattern>/*</url-pattern>
  </filter-mapping>
  
  #####第三方请求
  http://api.avatardata.cn/Weather/Query?key=8475ee0ca84144e89aaed5d8dd741a3a&cityname=%E5%8D%97%E4%BA%AC
  
  使用src访问第三方或者控制层去获取
  
  try {
URL url=new URL("http://api.avatardata.cn/Weather/Query?key=8475ee0ca84144e89aaed5d8dd741a3a&cityname=%E5%8D%97%E4%BA%AC");
HttpURLConnection connection=(HttpURLConnection)url.openConnection();
connection.connect();
InputStream inputStream=connection.getInputStream();
BufferedReader reader=new BufferedReader(new InputStreamReader(inputStream));
StringBuffer sBuffer=new StringBuffer();
String str="";
while((str=reader.readLine())!=null) {
sBuffer.append(str);
}
System.out.println(sBuffer);
} catch (MalformedURLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

####处理json跨域
$.ajax({
url:"",
type:"get",
dataType:"jsonp",
jsonp:"callback",
success:function(){
}
})

获取文件夹下的所有文件//使用递归获取所有文件夹下的所有文件
File dir=new File("d:/qq");
if(dir.isDirectory()){
File[] files=dir.listFiles();
}