java代码审计--之--常用框架了解
框架
框架：软件的半成品，为解决问题而指定的一套约束，在提供功能基础上进行扩充。
框架中一些不能被封装的代码（变量），需要新建xml文件，在文件中添加变量内容。
类库：没有封装逻辑
MyBatis
环境搭建
-
- 导入jar
Cglib依赖的包
动态代理包
日志包
MyBatis核心包
驱动 -
- 全局配置文件
在 src 下新建全局配置文件(编写 JDBC 四个变量)
引入 DTD 或 schema
DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="default">
<environment id="default">
<transactionManager type="JDBC">transactionManager>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/ssm"/>
<property name="username" value="root"/>
<property name="password" value="smallming"/>
dataSource>
environment>
environments>
<mappers>
<mapper resource="com/bjsxt/mapper/FlowerMapper.xml"/>
mappers>
configuration>
-
- 实体类名+Mapper.xml
-
编写需要执行的SQL命令，可把xml文件理解为xxxdaoimpl实现类
<select id="selAll"resultType="com.bjsxt.pojo.Flower">
select * from flower
select>
#{}
2.2.2.1 使用索引,从 0 开始 #{0}表示第一个参数
2.2.2.2 也可以使用#{param1}第一个参数
2.2.2.3 如果只有一个参数(基本数据类型或 String),mybatis
对#{}里面内容没有要求只要写内容即可.
2.2.2.4 如果参数是对象#{属性名}
2.2.2.5 如果参数是 map 写成#{key}
<select id="selById"
resultType="com.bjsxt.pojo.People"
parameterType="int">
select * from people where id=#{0}
select>
${}
-
在 xml 文件中出现 “<” , “>” ,双引号 等特殊字符时,可以使用 XML 文件转义标签
分页：?不允许在关键字,前后进行数学运算
- typeAliases 别名
<typeAliases>
<typeAlias type="com.bjsxt.pojo.People"
alias="peo"/>
typeAliases>
-
- 测试结果
只有在单独使用 mybatis 时使用,最后 ssm 整合时下面代
码不需要编写
InputStream is =
Resources.getResourceAsStream("myabtis.xml");
//使用工厂设计模式
SqlSessionFactory factory = new
SqlSessionFactoryBuilder().build(is);
//生产 SqlSession
SqlSession session=factory.openSession();
List<Flower> list =
session.selectList("a.b.selAll");
for (Flower flower : list) {
System.out.println(flower.toString());
}
session.close();
三种查询方式
-
selectList()
- 返回值为 List
适用于查询结果都需要遍历的需求
- 返回值为 List
List<Flower> list = session.selectList("a.b.selAll");
for (Flower flower : list) {
System.out.println(flower.toString());
}
-
selectOne()
- 返回值 Object 适用于返回结果只是变量或一行数据时
int count = session.selectOne("a.b.selById");
System.out.println(count);
-
selectMap()
- 返回值 Map 适用于需要在查询结果中通过某列的值取到这行数据的需求. Map
- 返回值 Map 适用于需要在查询结果中通过某列的值取到这行数据的需求. Map
Map<Object, Object> map = session.selectMap("a.b.c",
"name123");
System.out.println(map);
注解
简化 xml 文件的开发
如果涉及动态 SQL 依然使用 mapper.xml
注解可以有属性,因为注解其实就是一个接口(类)
注解语法: @XXXX(属性名= 值)
6.1 如果值是基本数据类型或字符串: 属性名=值6.2 如果值是数组类型: 属性名={值,值}
6.2.1 如果只有一个值可以省略大括号
6.3 如果值是类类型,属性名=@名称
-
路径
-
编写路径为了告诉编译器如何找到其他资源.
-
路径分类
2.1 相对路径: 从当前资源出发找到其他资源的过程
2.2 绝对路径: 从根目录(服务器根目录或项目根目录)出发找到其他资源的过程
标志: 只要以/开头的都是绝对路径 -
绝对路径:
3.1 如果是请求转发 / 表示项目根目录(WebContent)
3.2 其他重定向,等 / 都表示服务器根目录(tomcat/webapps 文件夹),,location.href
-
-
Log4j
在项目中编写 System.out.println();输出到控制台,当项目发布
到 tomcat 后,没有控制台log4j 作用,不仅能把内容输出到控制台,还能把内容输出到文件
中.便于观察结果-
- 导入 log4j-xxx.jar
-
- 在 src 下新建 log4j.properties
-
log4j.rootCategory=DEBUG, CONSOLE ,LOGFILE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppend
er
log4j.appender.CONSOLE.layout=org.apache.log4j.Patter
nLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%C %d{YYYY-MM-dd hh:mm:ss} %m %n
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=E:/my.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.Patter
nLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%C %m
%L %n
在 mybatis.xml 中开启 log4j
<settings>
<setting name="logImpl" value="LOG4J"/>
settings>
通过标签控制 mybatis 全局开关
-
实现
- 实现查询
@Select("select * from teacher")
List<Teacher> selAll();
- 实现新增
@Insert("insert into teacher
values(default,#{name})")
int insTeacher(Teacher teacher);
- 实现修改
@Update("update teacher set name=#{name} where id=#{id}")
int updTeacher(Teacher teacher);
- 实现删除
@Delete("delete from teacher where id=#{0}")
int delById(int id);
使用注解实现功能
在 TeacherMapper 接口添加
9.3.1 @Results() 相当于
9.3.2 @Result() 相当于或
9.3.2.1 @Result(id=true) 相当与
9.3.3 @Many() 相当于
9.3.4 @One() 相当于
@Results(value={
@Result(id=true,property="id",column="id"),
@Result(property="name",column="name"),
@Result(property="list",column="id",many=@Many(select="com.bjsxt.mapper.StudentMapper.selByTid"))
})
@Select("select * from teacher")
List<Teacher> selTeacher();
功能实现
-
新增
-
mybatis 中默认是关闭了 JDBC 的自动提交功能
功能:从应用程序角度出发,软件具有哪些功能.
业务:完成功能时的逻辑.对应 Service 中一个方法事务:从数据库角度出发,完成业务时需要执行的 SQL 集合,统称一个事务.
事务回滚.如果在一个事务中某个 SQL 执行事务,希望回归到事务的原点,保证数据库数据的完整性.
2.1 每一个 SqlSession 默认都是不自动提交事务.
2.2 session.commit()提交事务.
2.3 openSession(true);自动提交.setAutoCommit(true)mybatis 底层是对 JDBC 的封装.
3.1 JDBC 中 executeUpdate()执行新增,删除,修改的 SQL.返回值 int, 表示受影响的行数.
3.2 mybatis 中 标签没有 resultType 属性, 认为返回值都是 int在 openSession()时 Mybatis 会创建 SqlSession 时同时创建一个
Transaction(事务对象),同时 autoCommit 都为 false
如果出现异常,应该 session.rollback()回滚事务. -
- 在 mapper.xml 中提供标签,标签没有返回值类型
-
<insert id="ins" parameterType="People">
insert into people values(default,#{name},#{age})
insert>
-
- 通过 session.insert()调用新增方法
int index1 = session.insert("a.b.ins", p);
if(index1>0){
System.out.println("成功");
}else{
System.out.println("失败");
}
-
修改
-
- 在 mapper.xml 中提供标签
-
<update id="upd" parameterType="People">
update people set name = #{name} where id = #{id}
update>
-
- session.update
People peo = new People();
peo.setId(3);
peo.setName("王五");
int index = session.update("a.b.upd", peo);
if(index>0){
System.out.println("成功");
}else{
System.out.println("失败");
}
session.commit();
-
删除
-
- 在 mapper.xml 提供标签
-
<delete id="del" parameterType="int">
delete from people where id = #{0}
delete>
-
- session.delete
int del = session.delete("a.b.del",3);
if(del>0){
System.out.println("成功");}else{
System.out.println("失败");
}
session.commit();
-
多表查询
Mybatis 实现多表查询方式
1.1 业务装配.对两个表编写单表查询语句,在业务(Service)把查询
的两个结果进行关联.
1.2 使用 Auto Mapping 特性,在实现两表联合查询时通过别名完成映射.
1.3 使用 MyBatis 的标签进行实现.-
resultMap 标签
- 单表映射
-
<resultMap type="teacher" id="mymap">
<id column="id" property="id1" />
<result column="name" property="name1"/>
resultMap><select id="selAll" resultMap="mymap">
select * from teacher
select>
-
关联单个对象(N+1 方式)
- N+1 查询方式,先查询出某个表的全部信息,根据这个表的信息 查询另一个表的信息
- 实现步骤：1. 在 Student 实现类中包含了一个 Teacher 对象
- N+1 查询方式,先查询出某个表的全部信息,根据这个表的信息 查询另一个表的信息
public class Student {
private int id;
private String name;
private int age;
private int tid;
private Teacher teacher;
-
- 在 TeacherMapper 中提供一个查询
<select id="selById" resultType="teacher"
parameterType="int">
select * from teacher where id=#{0}
select>
-
- StudentMapper
4.3.3.1 装配一个对象时使用
4.3.3.2 property: 对象在类中的属性名
4.3.3.3 select:通过哪个查询查询出这个对象的信息
4.3.3.4 column: 把当前表的哪个列的值做为参数传递给另一个查询
4.3.3.5 大前提使用 N+1 方式.时如果列名和属性名相同可以不配置,使用 Auto mapping 特性.但是 mybatis 默认只会给列专配一次
<resultMap type="student" id="stuMap">
<id property="id" column="id"/>
<result property="name" column="name"/>
<result property="age" column="age"/>
<result property="tid" column="tid"/>
<association property="teacher"
select="com.bjsxt.mapper.TeacherMapper.selById"
column="tid">association>
resultMap>
<select id="selAll" resultMap="stuMap">
select * from student
select>
- 关联集合对象(N+1)
- 加载集合数据(联 合查询方式)
接口绑定方案
-
创建一个接口后把mapper.xml由mybatis 生成接口的实现 类,通过调用接口对象就可以获取 mapper.xml 中编写的 sql.
-
接口绑定实现步骤
-
- 创建一个接口
3.1.1 接口包名和接口名与 mapper.xml 中namespace
相同
3.1.2 接口中方法名和 mapper.xml 标签的 id 属性相同
-
public interface LogMapper {
List<Log> selAll();
}
-
-
使用进行扫描接口和 mapper.xml
mybatis.xml 中
-
<mappers><package name="com.bjsxt.mapper"/>
mappers>
-
-
新建LogMapper.xml
4.3.1 namespace 必须和接口全限定路径(包名+类名)一致
4.3.2 id 值必须和接口中方法名相同
4.3.3 如果接口中方法为多个参数,可以省略 parameterType
-
<mapper namespace="com.bjsxt.mapper.LogMapper">
<select id="selAll" resultType="log">
select * from log
select>
mapper>
-
多参数实现办法
-
- 接口中声明方法 List selByAccInAccout(String accin,String accout);
-
- 在 mapper.xml 中添加
#{}中使用 0,1,2 或 param1,param2
<select id="selByAccInAccout" resultType="log" >
select * from log where accin=#{0} and accout=#{1}
select>
-
注解方式实现
-
- 接口中声明方法
/**
* mybatis 把参数转换为 map 了,其中@Param("key") 参数内
容就是 map 的 value
* @param accin123
* @param accout3454235
* @return
*/
List<Log> selByAccInAccout(@Param("accin") String
accin123,@Param("accout") String accout3454235);
-
- 在 mapper.xml 中添加
#{} 里面写@Param(“内容”)参数中内容
<select id="selByAccInAccout" resultType="log" >
select * from log where accin=#{accin} and accout=#{accout}
select>
动态 SQL
- 根据不同的条件需要执行不同的 SQL 命令。MyBatis 中动态 SQL 在 mapper.xml 中添加逻辑判断等.
<select id="selByAccinAccout" resultType="log">
select * from log where 1=1
<if test="accin!=null and accin!=''">
and accin=#{accin}
if>
<if test="accout!=null and accout!=''">
and accout=#{accout}
if>
select>
-
4.1 当编写 where 标签时,如果内容中第一个是 and 去掉第一个 and
4.2 如果中有内容会生成 where 关键字,如果没有内容不 生成 where 关键 -
-
6.1 作用:去掉最后一个逗号
6.2 作用:如果6.3 示例
6.3.1 id=#{id} 目的防止 -
7.1 prefix 在前面添加内容
7.2 prefixOverrides 去掉前面内容
7.3 suffix 在后面添加内容
7.4 suffixOverrieds 去掉后面内容
7.5 执行顺序去掉内容后添加内容 -
场景:8.2.1 模糊查询
8.2.2 在原内容前或后添加内容
<select id="selByLog" parameterType="log"
resultType="log">
<bind name="accin" value="'%'+accin+'%'"/>
#{money}
select>
-
循环参数内容,还具备在内容的前后添加内容,还具备添加分隔符功能.
适用场景:in 查询中.批量新增中(mybatis 中 foreach 效率比较 低)
-
和
10.1 某些 SQL 片段如果希望复用,可以使用定义这个片段
<sql id="mysql">
id,accin,accout,money
sql>
10.2 在 数据库连接池 1.在内存中开辟一块空间,存放多个数据库连接对象. 3.1 active 状态:当前连接对象被应用程序使用中 在高频率访问数据库时,使用数据库连接池可以降低服务器系 当关闭连接对象时,把连接对象归还给数据库连接池,把状态 改变成 Idle ThreadLocal 线程容器,给线程绑定一个 Object 内容,后只要线程不变,可以随时 取出。改变线程,无法取出内容。 缓存 缓存存在的意义:让应用程序减少对数据库的访问,提升程序运行效率 MyBatis 中默认 SqlSession 缓存开启 3.1 同一个 SqlSession 对象调用同一个 缓存流程 4.1 步骤一: 先去缓存区中找是否存在 statement SqlSessionFactory 缓存 5.1 又叫:二级缓存 5.4 使用二级缓存步骤 5.5 当 SqlSession 对象 close()时或 commit()时会把 SqlSession 缓存的数据刷(flush)到 SqlSessionFactory 缓存区中 运行过程中涉及到的类 1.1 Resources MyBatis 中 IO 流的工具类 1.2 SqlSessionFactoryBuilder() 构建器 1.3 XMLConfigBuilder MyBatis 全局配置文件内容构建器类 1.4 Configuration 封装了全局配置文件所有配置信息. 1.5 DefaultSqlSessionFactory 是SqlSessionFactory接口的实现类 1.6 Transaction 事务类 1.7 TransactionFactory 事务工厂 1.8 Executor MyBatis 执行器1.8.1 作用:负责执行 SQL 命令 1.9 DefaultSqlSession 是 SqlSession 接口的实现类 流程图 文字解释 在 MyBatis 运行开始时需要先通过 Resources 加载全局配置文件.下面 Spring 几大核心功能 test: spring 提供测试功能 Core Container:核心容器.Spring 启动最基本的条件 AOP: 实现 aop 功能需要依赖 Aspects: 切面 AOP 依赖的包 Data Access/Integration : spring 封装数据访问层相关内容 WEB:需要 spring 完成 web 相关功能时需要 配置的信息最终存储到了 AppliationContext 容器中 spring 配置文件是基于 schema 2.3.1 schema 文件扩展名.xsd 2.3.2 把 schema 理解成 DTD 的升级版. 2.3.3 每次引入一个 xsd 文件是一个 namespace(xmlns) 3.1 getBean(“标签 id 值”,返回值类型);如果没有第二个参数, 默认是 Object 构造方法 无参构造创建:默认情况 有参构造创建:需要明确配置 1.2.2.2 index : 参数的索引,从 0 开始 实例工厂 静态工厂 不需要创建工厂,快速创建对象 当一个类(A)中需要依赖另一个类()对象时,把 B 赋值给 A 的过 在程序原有纵向执行流程中,针对某一个或某一些方法添加通 5.1 原有功能: 切点, pointcut AOP 实现方式 1. Schema-based 6.1.1 每个通知都需要实现接口或类 2.1 新建前置通知类 配置 spring 配置文件 3.1 引入 aop 命名空间 6.2.1 每个通知不需要实现接口或类 配置异常通知的步骤 1 新建类,在类写任意名称的方法 2 在 spring 配置文件中配置 3.2.1 spring 不会自动去寻找注解,必须告诉 spring 哪些包下的类中可能有注解 引入 xmlns:context @Component 相当于 @Aspect 在方法上添加@Pointcut(“”) 定义切点 设计模式：前人总结的一套解决特定问题的代码. 代理设计模式优点： 静态代理设计模式 由代理对象代理所有真实对象的功能. 1.1 自己编写代理类 动态代理 JDK 提供的 优点：jdk 自带,不需要额外导入 jar 代码流程： cglib 动态代理 1.1 基于字节码,生成真实对象的子类. 1.在 Spring 配置文件中对象名和 ref=”id”id 名相同使用自动注入,可以 不配置 2.两种配置办法 3.autowire=”” 可取值 在 spring 配置文件中先引入 xmlns:context,在下面添加 如果需要记载多个配置文件逗号分割 作用: 在应用程序有保证最多只能有一个实例 scope 可取值 1.编程式事务: 2.声明式事务: 重要组件 运行原理 如果在 web.xml 中设置 DispatcherServlet 的为/时,当用户发 起 请 求 , 请 求 一 个 控 制 器 , Spring 容器和 SpringMVC 容器是父子容器 字符编码过滤器 在 web.xml 中配置 Filter tomcat一启动就被实例化，等待回调 视图解析器 如果希望不执行自定义视图解析器,在方法返回值前面添加 @ResponseBody 在方法上添加@ResponseBody(恒不跳转) 2.1 如果返回值满足 key-value 形式(对象或 map) 2.2 如果返回值不满足 key-value,例如返回值为 String JSP 九大内置对象 四大作用域 如 果 不 配 置 引入 xmlns:mvc 命名空间 基本数据类型参数 默认保证参数名称和请求中传递的参数名相同 还可以获取httpservletrequestreq参数 如果请求参数名和方法参数名不对应使用@RequestParam()赋 值 如果方法参数是基本数据类型(不是封装类)可以通过 @RequestParam 设置默认值. 如果强制要求必须有某个参数 restful 传值方式 7.1 简化 jsp 中参数编写格式 7.3 在控制器中 把内容写到方法(HandlerMethod)参数中,SpringMVC 只要有这个内 容,注入内容 HandlerMethod 中参数是对象类型 请求参数名和对象中属性名对应(get/set 方法) 请求参数中包含多个同名参数的获取方式 复选框传递的参数就是多个同名参数 请求参数中对象.属性格式 jsp 中代码 新建一个类 ：对象名和参数中点前面名称对应 在请求参数中传递集合对象类型参数 jsp 中格式 新建类 在 HanlderMethod 参数中添加作用域对象 使用 Map 集合 2.1 把 map 中内容放在 request 作用域中 使用 SpringMVC 中 Model 接口 把内容最终放入到 request 作用域中. 访问资源时相应头如果没有设置 Content-Disposition,浏览器默认按照 inline 值进行处理。inline 能显示就显示,不能显示就下载. 只需要修改相应头中 Context-Disposition=”attachment;filename=文件名” 实现步骤 在 springmvc 中放行静态资源 files 文件夹 基于 apache 的 commons-fileupload.jar 完成文件上传. MultipartResovler 作用: （springMVC的组件） 表单数据类型分类 实现步骤： post最大2GB，字节流 MultipartFile 对象名必须和的 name 属性值相同 1.跟过滤器比较像的技术. 2.发送请求时被拦截器拦截,在控制器的前后添加额外功能. 3.SpringMVC 拦截器和 Filter 的区别 拦截所有控制器 拦截特定的的 url 拦截器栈 多个拦截器同时生效时,组成了拦截器栈 顺序：先进后出. 执行顺序和在 springmvc.xml 中配置顺序有关 设置先配置拦截器 A 在配置拦截器 B 执行顺序为 在 springmvc.xml 中配置,代码中不需要做任何修改 1.1 必须额外导入 joda-time.jar 使 用 注 解 . 在 需 要 转 换 的 参 数 或 实 体 类 属 性 上 添 加 @DateTimeFormatter(pattern=”表达式”) 2.1 使用 Date 参数接收 2.2 在实体类中 2.3 注意地方: 基于角色的访问控制 一种思想.根据 RBAC 思想进行数据库设计,根据数据库设计更 权限控制常用分类: JUnit来源 难点在于有很多名词 Shiro 不会去维护用户、维护权限；这些需要我们自己去设计/提供；然后通过 Primary Concerns Authentication 用户是否合法 身份认证/登录，验证用户是不是拥有相应的身份； Authorization 授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用 户是否能做事情， Session Manager 会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信 息都在会话中； 登录信息持久化 用户登录后的用户信息通过session management来进行管理，不管在什么应用中。 Cryptography 加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储； 盐，散列 Supporting Features Web Support：Web 支持，可以非常容易的集成到 Web 环境； Subject 需要进行认证和身份授权的用户或第三方程序，用于获取主体信息 Subject 即主体，外部应用与 subject 进行交互，subject 记录了当前操作用户，将用户的 概念理解为当前操作的主体，可能是一个通过浏览器请求的用户，也可能是一个运行的程序。 SecurityManager SecurityManager 即安全管理器，对全部的 subject 进行安全管理，它是 shiro 的核心， Authenticator Authenticator 即认证器，对用户身份进行认证，Authenticator 是一个接口，shiro 提供 Authorizer Authorizer 即授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用 realm Realm 即领域，相当于 datasource 数据源， 注意：不要把 realm 理解成只是从数据源取数据，在 realm 中还有认证授权校验的相关 的代码。 其他 1.4.6 sessionManager 在应用中谁能证明他就是他本人。一般提供如他们的身份 ID 一些标识信息来 表明他就是他本人，如提供身份证，用户名/密码来证明。 在 shiro 中，用户需要提供 principals （身份）和 credentials（证明）给 shiro，从而应用能 验证用户身份 principals credentials ini文件可以进行数据分组 通过 Shiro.ini 配置文件初始化 SecurityManager 环境。 写数据库里也行 常见异常信息及处理： 认证过程中有个父异常AuthenticationException子类AccountException，DisableAccountException等 Shiro 默认使用自带的 IniRealm，IniRealm 从 ini 配置文件中读取用户的信息，大部分情 况下需要从系统的数据库中读取用户信息，所以需要自定义 realm。 jdbcRealm实现从数据库获取用户的验证信息，但不够灵活。 配置 Realm 需要在 shiro.ini 配置 realm 注入到 securityManager 中。 散列算法一般用于生成数据的摘要信息，是一种不可逆的算法，一般适合存储密码之类 的数据，常见的散列算法如 MD5、SHA 等。一般进行散列时最好提供一个 salt（盐），比如 加密密码“admin”，产生的散列值是“21232f297a57a5a743894a0e4a801fc3”，可以到一 些 md5 解密网站很容易的通过散列值得到密码“admin”，即如果直接对密码进行散列相对来说破解更容易，此时我们可以加一些只有系统知道的干扰数据，如用户名和 ID（即盐）；这样散列的对象是“密码+用户名+ID”，这样生成的散列值相对来说更难破解 Realm 配置 Shiro.ini 在配置文件中，需指定凭证匹配器 [main] 配置应用程序的securitymanager实例及任何它的以来组件（如realms） [users]定义一组静态用户，角色 也叫访问控制，即在应用中控制谁能访问哪些资源（如访问页面/编辑数据/页面 操作等）。在授权中需了解的几个关键对象：主体（Subject）、资源（Resource）、权限（Permission）、角色（Role） 关键对象 主体：即访问应用的用户，在 Shiro 中使用 Subject 代表该用户。用户只有授权后才允许访 问相应的资源。 资源：在应用中用户可以访问的任何东西，比如访问 JSP 页面、查看/编辑某些数据、访问某个业 务方法、打印文本等等都是资源。用户只要授权后才能访问。 角色：代表了操作集合，可以理解为权限的集合，一般情况下我们会赋予用户角色而不是权 限，即这样用户可以拥有一组权限，赋予权限时比较方便。典型的如：项目经理、技术总监、CTO、开发工程师等都是角色，不同的角色拥有一组不同的权限。 权限粒度 粗粒度：对表的操纵，如对user的crud 权限表示规则： 授权流程 流程如下： 授权方式 Shiro 支持三种方式的授权： 编程式：通过写 if/else 授权代码块完成： 注解式：通过在执行的 Java 方法上放置相应的注解完成： 没有权限将抛出相应的异常； JSP/GSP 标签：在 JSP/GSP 页面通过相应的标签完成： 授权实现 与上边认证自定义 realm 一样，大部分情况是要从数据库获取权限数据，这里直接实现 基于资源的授权。 配置文件 完成 springmvc+spring+mybatis 整合 web.xml 中配置 shiro 的 filter !-- shiro过虑器，DelegatingFilterProxy通过代理模式将spring容器中的bean和 原理 Shiro 内置了很多默认的过滤器，比如身份验证、授权等相关的。默认过滤器可以参考 anon:例子/admins/=anon 没有参数，表示可以匿名使用。 FormAuthenticationFilter 拦截住取出 request 中的 username 和 password（两个参数 名称是可以配置的） FormAuthenticationFilter 调用 realm 传入一个 token（ username 和 password） realm 认证时根据 username 查询用户信息（在 Activeuser 中存储，包括 userid、 usercode、username、menus）。 登陆页面 由于 FormAuthenticationFilter 的用户身份和密码的 input 的默认值（ 代码实现 持久化：数据从瞬时状态转化为持久状态 Hibernate：是一个轻量级的持久化框架。没有侵入性。是一个 orm 映射框架。简化了 jdbc操作。极大了提高了开发效率。提供了缓存机制。强大的查询机制。支持多种数据库（数据库移植） 映射规则： （拷贝 project/etc/hibernate.cfg.xml） pojo对象必须提供无参构造方法 将映射文件加入到 hibernate.cfg.xml 别的获取数据的方法 对象的 3 种状态： 总结： 在 src 下添加 struts2 的配置文件，struts.xml struts.xml–文件名不能改 Xml 文件的头文件—拷贝一个 struts.xml 文件，或者到 core 包下的 struts-default.xml 文件中拷贝。 注：到这里 struts2 的框架搭建完成 编写 Action 类 注：在 servlet 中，默认执行 service 方法。在 struts2 中，默认执行 execute 方法。 配置 action 类 在 struts.xml 文件中，配置 HelloAction 访问： 执行流程 当用户提交一个请求，服务器接收，并且交给 struts2 的核心过滤器来进行处理，struts2 的过滤器调用 struts2 的一系列处理器来进行处理（如：解析 struts.xml 配置文件，和用户提 交的请求对比，如果找不到返回 404，如果找到进行下一步处理。）直到调用对应的 Action 类中的 execute 方法执行，执行完后再进行一系列处理到核心过滤器。由核心过滤器返回给 发起请求—》服务器接受请求并交给struts2前端控制器–》根据请求的url查看struts.xml 中的 namespace + actionName —》执行action所对应的类的对应方法—》根据方法的执行结果到action的结果集进行匹配–》响应结果 回顾 在 jsp/servlet 开发中，首先使用的是 框架：框架替程序员完成一部分的代码。从而提高开发效率 struts1出现很早，名气很大，局限性（支持前端的技术很窄，只jsp） 然后出现了webwork，支持新的技术，名气不大。 mvc 框架完成的事情： Mvc 框架做的事情： struts2 线程安全 1、线程安全：在一个进程中有多个线程并发执行，每个线程执行过程中，变量值是相同的， 执行结果也是相同的。 2、Struts2 线程安全吗？ token令牌 防止用户重复提交，造成冗余数据，使用token默 认拦截器解决。后台生成token令牌，一份存在 session中，一份存在jsp页面展示提交到action ，对比session中的token值， struts2 的 ajax 使用 ServletApi 实现 ajax 使用 struts2 插件来实现 ajax 处理(返回 json 格式数据) 导入相关的 jar 包 Action 代码 常量配置 1)乱码解决 2)自定义扩展名 3)友好的提示信息 4)设置配置文件修改后自动加载–推荐在开发中使用 常量配置方式二 团队协作开发配置 通过 include 添加不同人员的配置文件 配置文件加载顺序 package 的配置 action 的配置 class不写的话就是默认类 在常量配置中开启DMI 使用注解方法减少action的配置 result 配置 在 action 的配置中，如果不去配置 class 属性，将会由默认的 action 来执行，默认的 action 是 ActionSuppot 类。 1、定义一个 pojo 类 无侵入性，将来好换框架 好处：自定义一个普通的 java 类即可，不具有侵入型 2、实现 Action 接口 大家使用的比较少 3、继承 ActionSupport 类 好处：可以继承一些 ActionSuport 实现功能，如：验证；官方推荐使用 属性驱动 使用struts2获取表单数据，只需表单域名称和action处理类的属性名称一致，并提供属性的set方法，那 么在action处理类中即可获得表单数据。这种获取数据方式称为属性驱动。 以对象的方式处理表单数据 对象驱动 属性多的时候就封装为对象 模型驱动 对象驱动中，页面的表单域名称比较复杂 建议在实体类属性比较多时，采用模型驱动进行开发。 类型转换 在 servlet 中 如果表单提交非字符串数据的时候，需要进行类型转换：如提交 age 在 struts2 中，常见数据类型 struts2 已经自动的进行了类型转换。在某些情况下，有自定义的类型时，struts2 不能完成类型转换，那么需要手动转换，如 果该自定义类型使用的频率较高时，手动转换重复代码将会增多-------使用 struts2 提供的类 案例：坐标点(x,y) 不进行类型转换的处理方式 Jsp 页面 这种方式不符合数学的表示形式；采用类型转换的处理： 使用类型转换 编写类型转换器–继承 StrutsTypeConverter 类 xwork-conversion.properties 配置文件 放于 src 下；内容为 要转换的类型=类型转换器 struts2 有 2 种方式去获取 servletAPI：一种解耦，一种耦合； 解耦使得使用 struts2 来进行测试的时候 不需要启动服务器。在一定程度上提高开发效 率的。 使用解耦的方式来获取 servlet api;通过 ActionContext 对象获取。 用户登录后将信息写入session 通过耦合的方法获取 HttpServletRequest ActionContext 是 map 结构的容器。ActionContext 是 Action 的上下文（生命周期长），存放 Action 执行 过程中数据信息。ActionContext 存放 Action 的数据，ActionInvocation,request 的数据，session 的数据，application 的数据，locale 的数据，conversion errors 等。每次请求时会为当前线程 创 建 一 个 新 的 ActionContext 。 而 ActionContext 采 用 了 ThreadLocal 的 方 式 来 存 放 ActionContext 所以 ActionContext 是线程安全。 将servletAPI中的数据存入actioncontext 实现了struts2和servlet的解耦。使测试可以不依赖 于容器 ThreadLocal模式 threadlocal也是个容器，存放在该容器的数据是线程安全的，谁放的谁取不会变 获取 ActionContext ActionContext.getContext()获取。由于 ActionContext 是线程安全的，并且是通过静态方 注意：ActionContext 是基于请求创建的，所以在非请求的线程中是不能使用 6 大对象 application ：servletcontext httpservletrequest中有两种数据： 值栈 ValueStack 值栈是栈结构；特征：FILO(先进后出)； ognl 表达式—el,re,ognl----用简洁的表达式完成比较复杂的功能。 actioncontext做ognl的上下文对象 struts2 标签 struts2 中使用 ognl 表达式是通过 struts2 的标签来取值的。 注意：要使用 struts2 的标签，那么要通过 struts2 过滤器来启用。如果过滤器的配置为 *.action 结尾时，不能直接访问 jsp 页面的。需要通过 action 跳转。如果过滤器配置为/*时， 可以直接访问 jsp 页面。 数据校验分2类 struts2提供两种后端校验方式 服务端验证 如果 action 类继承 ActionSupport 类，那么该 action 类将会继承 ActionSupport 的相关功能：如：验证功能 注意：如果执行的是 Action 中的 execute 方法，那么只会执行 validate 方法。如果执行的是自定义的 action ，register 方法，那么将会线执行 validateRegister–validate–register 方法。 案例 struts2 的验证框架 使用验证框架的步骤：在对应的 action 的包下添加一个验证框架的配置文件 该文件名为:actionName-validation.xml 拦截器实现是通过代理实现的aop 应禁止使用jsp直接访问页面，而应该通过. action方法返回jsp页面，这样就可以进入拦截器 ，也更安全 拦截器和过滤器 很相似。在 action 执行的前后执行。Struts2 的核心功能都是通 过拦截器来实现。 作用：对于 action 的一些公共处理代码可以放到拦截器中来实现。如：权限控制，日志 等等。 多个拦截器之间的执行是采用责任链设计模式来实现。 struts2所有功能都是可插拔 实现步骤 编写拦截器 自定义拦截器实现步骤： 当请求 hello.action 时将会执行该拦截器。 拦截器的配置详解 当引用了自定义拦截器时，默认拦截器将不起作用 默认拦截器:在 struts-default.xml 中，配置了默认拦截器。当配置默认拦截器以后， 当引用自定义拦截器后，又想使用 struts2 提供的拦截器功能，那么需要手动引用 当自定义拦截器栈在这个包下的所有 action 都使用的时，可以定义为默认的拦截器 栈，或默认的拦截器 登录案例 方法拦截器 方法拦截器时比 Action 拦截器更加细粒度的控制，主体实现和 Action 拦 文件上传 struts2 的文件上传功能使用的是 apache 下的 commons-fileupload 来实现。 Jsp Jsp 的表单要求是 post 提交，并且 enctype=”multipart/form-data” action 的代码：在 Action 中需要提供 3 个属性，一个 File 类型，名称是表单域名，其它 struts.xml 配 置 文 件 的 编 写 ； 主 要 是 上 传 文 件 大 小 的 控 制 。 需 要 配 置 拦 截 器 的 maximumSize 属性和 struts2 的静态属性：struts.multipart.maxSize；maxSize 要大于等于 maximumSize。 struts2 可以将批量文件处理为数组上传到 action 中 文件下载 在 servlet 中的文件下载是通过流来实现的。 通过流来实现下载 使用 struts2 本来结果集来进行文件下载 Action <select id="">
select <include refid="mysql">include>
from logselect>
其他
2.JDBC Tomcat Pool,直接由 tomcat 产生数据库连接池
3.2 Idle 空闲状态:等待应用程序使用
统压力,提升程序运行效率.
<Context>
<Resource
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/ssm"
username="root"password="smallming"
maxActive="50"
maxIdle="20"
name="test"
auth="Container"
maxWait="10000"
type="javax.sql.DataSource"
/>
Context>
Context cxt = new InitialContext();
DataSource ds = (DataSource)
cxt.lookup("java:comp/env/test");
Connection conn = ds.getConnection();
https://www.bilibili.com/video/BV137411V7Y1?p=678&spm_id_from=pageDriver
final ThreadLocal<String> threadLocal = new
ThreadLocal<>();
threadLocal.set("测试");
new Thread(){
public void run() {
String result = threadLocal.get();
System.out.println("结果:"+result);
};
}.start();
4.2 步骤二:返回结果
4.3 步骤三:如果没有缓存 statement 对象,去数据库获取数据
4.4 步骤四:数据库返回查询结果
4.5 步骤五:把查询结果放到对应的缓存区中
5.2 有效范围:同一个 factory 内哪个 SqlSession 都可以获取
5.3 什么时候使用二级缓存？
当数据频繁被使用,很少被修改
5.4.1 在 mapper.xml 中添加
5.4.2 如果不写 readOnly=”true”需要把实体类序列化 <cache readOnly="true">cache>
运行原理
1.1.1 加载配置文件
1.2.1 作用:创建 SqlSessionFactory 接口的实现类
1.3.1 作用负责读取流内容并转换为 JAVA 代码.
1.4.1 全局配置文件内容存放在 Configuration 中
16.1 每一个 SqlSession 会带有一个 Transaction 对象.
1.7.1 负责生产 Transaction
1.8.2 相当于 JDBC 中 statement 对象(或 PreparedStatement
或 CallableStatement)
1.8.3 默认的执行器 SimpleExcutor
1.8.4 批量操作 BatchExcutor
1.8.5 通过 openSession(参数控制)
1.10 ExceptionFactory MyBatis 中异常工厂
需要实例化 SqlSessionFactoryBuilder 构建器.帮助 SqlSessionFactory 接
口实现类 DefaultSqlSessionFactory.
在实例化 DefaultSqlSessionFactory 之前需要先创建 XmlConfigBuilder
解析全局配置文件流,并把解析结果存放在 Configuration 中.之后把
Configuratin 传递给 DefaultSqlSessionFactory.到此 SqlSessionFactory 工
厂创建成功.
由 SqlSessionFactory 工厂创建 SqlSession.
每次创建 SqlSession 时,都需要由 TransactionFactory 创建 Transaction
对象,同时还需要创建 SqlSession 的执行器 Excutor,最后实例化
DefaultSqlSession,传递给 SqlSession 接口.
根据项目需求使用 SqlSession 接口中的 API 完成具体的事务操作.
如果事务执行失败,需要进行 rollback 回滚事务.
如果事务执行成功提交给数据库.关闭 SqlSession
到此就是 MyBatis 的运行原理.(面试官说的.)Spring
4.1 IoC/DI 控制反转/依赖注入
4.2 AOP 面向切面编程
4.3 声明式事务.Spring Framework Runtime
环境搭建
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/sc
hema/beans
http://www.springframework.org/schema/beans/spring-be
ans.xsd">
<bean id="peo" class="com.bjsxt.pojo.People"/>
beans>
2.3.2.1 比 DTD 具备更好的扩展性.
3.2 getBeanDefinitionNames(),Spring 容器中目前所有管理的所有对象 ApplicationContext ac = new
ClassPathXmlApplicationContext("applicationContext.xm
l");
People people = ac.getBean("peo",People.class);
System.out.println(people);
// String[] names = ac.getBeanDefinitionNames();
// for (String string : names) {
// System.out.println(string);
// }
Spring 创建对象的三种方式
1.2.2.3 name: 参数名
1.2.2.4 type:类型(区分开关键字和封装类 int 和 Integer) <bean id="peo" class="com.bjsxt.pojo.People">
<constructor-arg index="0" name="id" type="int"
value="123">constructor-arg>
<constructor-arg index="1" name="name"
type="java.lang.String" value="张三
">constructor-arg>
bean>
public class PeopleFactory {
public People newInstance(){
return new People(1,"测试");}
}
<bean id="factory" class="com.bjsxt.pojo.PeopleFactory">bean>
<bean id="peo1" factory-bean="factory"
factory-method="newInstance">bean>
public class PeopleFactory {
public static People newInstance(){
return new People(1,"测试");
}
}
<bean id="peo2" class="com.bjsxt.pojo.PeopleFactory"
factory-method="newInstance">bean>
Bean 属性赋值(注入)
DI
程就叫做依赖注入<bean id="peo" class="com.bjsxt.pojo.People">
<property name="desk" ref="desk">property>
bean>
<bean id="desk" class="com.bjsxt.pojo.Desk">
<property name="id" value="1">property>
<property name="price" value="12">property>
bean>
AOP
知,形成横切面过程就叫做面向切面编程
5.2 前置通知: 在切点之前执行的功能. before advice
5.3 后置通知: 在切点之后执行的功能,after advice
5.4 如果切点执行过程中出现异常,会触发异常通知.throws dvice
5.5 所有功能总称叫做切面.
5.6 织入: 把切面嵌入到原有功能的过程叫做织入
6.1.2 配置 spring 配置文件时在
2.1.1 arg0: 切点方法对象 Method 对象
2.1.2 arg1: 切点方法参数
2.1.3 arg2:切点在哪个对象中public class MyBeforeAdvice implements
MethodBeforeAdvice {
@Override
public void before(Method arg0, Object[] arg1, Objectarg2) throws Throwable {
System.out.println("执行前置通知");
}
}
3.2 配置通知类的
3.3 配置切面
3.4 * 通配符,匹配任意方法名,任意类名,任意一级包名
3.5 如果希望匹配任意方法参数 (…)
<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"
xsi:schemaLocation="http://www.springframework.org/sc
hema/beans
http://www.springframework.org/schema/beans/spring-be
ans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.
xsd">
<bean id="mybefore"
class="com.bjsxt.advice.MyBeforeAdvice">bean><bean id="myafter"
class="com.bjsxt.advice.MyAfterAdvice">bean>
<aop:config>
<aop:pointcut expression="execution(*
com.bjsxt.test.Demo.demo2())" id="mypoint"/>
<aop:advisor advice-ref="mybefore"
pointcut-ref="mypoint"/>
<aop:advisor advice-ref="myafter"
pointcut-ref="mypoint"/>
aop:config>
<bean id="demo" class="com.bjsxt.test.Demo">bean>
beans>
public class Test {
public static void main(String[] args) {
ApplicationContext ac = new
ClassPathXmlApplicationContext("applicationContext.xm
l");
Demo demo = ac.getBean("demo",Demo.class);
demo.demo1();
demo.demo2();
demo.demo3();
6.2.2 配置 spring 配置文件是在
public class MyThrowAdvice{
public void myexception(Exception e1){
System.out.println("执行异常通知
"+e1.getMessage());
}
}
3.2.2
3.2.3 method: 当触发这个通知时,调用哪个方法
3.2.4 throwing: 异常对象名,必须和通知中方法参数名相同(可
以不在通知中声明异常对象)<bean id="mythrow"
class="com.bjsxt.advice.MyThrowAdvice">bean>
<aop:config>
<aop:aspect ref="mythrow">
<aop:pointcut expression="execution(*
com.bjsxt.test.Demo.demo1())" id="mypoint"/>
<aop:after-throwing method="myexception"
pointcut-ref="mypoint" throwing="e1"/>aop:aspect>
aop:config>
<bean id="demo" class="com.bjsxt.test.Demo">bean>
<context:component-scan base-package="com.bjsxt.advice">context:component-scan>
代理
2.1 保护真实对象
2.2 让真实对象职责更明确.
2.3 扩展
1.2 每个代理的功能需要单独编
缺点：
1.2.1 真实对象必须实现接口
1.2.2 利用反射机制.效率不高
2. Mishu类实现InvocationHandler（代理实例的调用处理程序实现的接口）该接口下只有invoke方法
private Laozong laozong=new Laozong():
public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{ System.out.
println("预约时间"）；Object result=method.invoke(laozong,args);
System.out.println("记录访客信息");return result;}
3.Women类
newProxyInstance参数一是反射时使用的类加载器，参数二是Proxy需要实现什么接口，参数三是通过接口对
象调用方法时，需要调用哪个类的invoke方法）
Mishu mishu=new Mishu();
Gonneng gongneng=(Gongneng)Proxy.newProxyInstance(Women.class.getClassLoader(),new Class[]
{Gongneng.class},mishu);gongneng.chifan();}
运行效率高于 JDK 动态代理.
1.2 不需要实现接口
使用 spring aop 时,只要出现 Proxy 和真实对象转换异常
3.1 设置为 true 使用 cglib
3.2 设置为 false 使用 jdk(默认值) <aop:aspectj-autoproxy
proxy-target-class="true">aop:aspectj-autoproxy>
Mishu类实现MethodInterceptor
public Object intercept(Object arg0,Method arg1,Object[] arg2,MethodProxy arg 3)
throws Throwable{
System.out.println("预约时间");
Object result=arg1.invoke(arg0,arg2);或者是arg3.invokeSuper(arg0,arg2)
System.out.println("备注");
return result;}
Women类
Enhancer enhancer=new Enhancer():
enhancer.setSuperclass(Laozong.class);
enhancer.setCallback(new Mishu());
Laozong laozong=(Laozong) enhancer.create();
laozong.chifan();
自动注入
2.1 在
3.1 default: 默认值,根据全局 default-autowire=””值.默认全局和局部都没有配置情况下,相当于 no
3.2 no: 不自动注入3.3 byName: 通过名称自动注入.在 Spring 容器中找类的 Id
3.4 byType: 根据类型注入.
3.4.1 spring 容器中不可以出现两个相同类型的
3.5.1 提供对应参数的构造方法(构造方法参数中包含注入对 戏那个)
3.5.2 底层使用 byName, 构造方法参数名和其他加载 properties 文件
<context:property-placeholder
location="classpath:db.properties"/>
@Value(“${key}”)取出properties中内容单例设计模式
实现数据共享. 案例:application 对象
4.1 singleton 默认值,单例
4.2 prototype 多例,每次获取重新实例化
4.3 request 每次请求重新实例化
4.4 session 每个会话对象内,对象是单例的.
4.5 application 在 application 对象内是单例
4.6 global session spring 推 出 的 一 个 对 象 , 依 赖 于 spring-webmvc-portlet ,类似于 session声明式事务
1.1 由程序员编程事务控制代码.
1.2 OpenSessionInView 编程式事务
2.1 事务控制代码已经由 spring 写好.程序员只需要声明出哪些方法需要进行事务控制和如何进行事务控制.
3.声明式事务都是针对于 ServiceImpl 类下方法的.
4.事务管理器基于通知(advice)的.
5.在 spring 配置文件中配置声明式事务<context:property-placeholder
location="classpath:db.properties,classpath:second.pr
operties"/>
<bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName"
value="${jdbc.driver}">property>
<property name="url"
value="${jdbc.url}">property>
<property name="username"
value="${jdbc.username}">property>
<property name="password"
value="${jdbc.password}">property>
bean>
<bean id="txManager"
class="org.springframework.jdbc.datasource.DataSour
ceTransactionManager">
<property name="dataSource"
ref="dataSource">property>
bean>
<tx:advice id="txAdvice"transaction-manager="txManager">
<tx:attributes>
<tx:method name="ins*" />
<tx:method name="del*" />
<tx:method name="upd*" />
<tx:method name="*" />
tx:attributes>
tx:advice>
<aop:config>
<aop:pointcut expression="execution(*
com.bjsxt.service.impl.*.*(..))"
id="mypoint" />
<aop:advisor advice-ref="txAdvice"
pointcut-ref="mypoint" />
aop:config>
SpringMVC
简介
首 先 会 执 行 DispatcherServlet由DispatcherServlet调用HandlerMapping的DefaultAnnotationHandlerMapping 解 析 URL,
解 析 后 调 用 HandlerAdatper 组 件 的 AnnotationMethodHandlerAdapter 调 用 Controller 中的 HandlerMethod.
当 HandlerMethod 执行完成后会返回 View,会被 ViewResovler 进行视图解析,
解析后调用 jsp 对应的.class 文 件并运行,
最终把运行.class 文件的结果响应给客户端. 以上就是 springmvc 运行原理(给面试官说的
<filter>
<filter-name>encodingfilter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
<init-param>
<param-name>encodingparam-name>
<param-value>utf-8param-value>
init-param>
filter>
<filter-mapping>
<filter-name>encodingfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalR
esourceViewResolver">
<property name="prefix" value="/">property>
<property name="suffix" value=".jsp">property>
bean>
forward:或 redirect:
2.1.1 把响应头设置为 application/json;charset=utf-8
2.1.2 把转换后的内容输出流的形式响应给客户端.
2.2.1 把相应头设置为 text/html
2.2.2 把方法返回值以流的形式直接输出.
2.2.3 如果返回值包含中文,出现中文乱码
2.2.3.1 produces 表示响应头中 Content-Type 取值.@RequestMapping(value="demo12",produces="text/html;
charset=utf-8")@ResponseBody
public String demo12() throws IOException{
People p = new People();
p.setAge(12);
p.setName("张三");
return "中文";
}
3.1 spring4.1.6 对 jackson 不支持较高版本,jackson 2.7 无效
环境搭建
/WEB-INF/ <servlet>
<servlet-name>jqkservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet<
SpringMVC 容器/servlet-class>
<init-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:springmvc.xmlparam-value>
init-param>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>jqkservlet-name>
<url-pattern>/url-pattern>
servlet-mapping>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<context:component-scan
base-package="com.bjsxt.controller">context:component-scan>
<mvc:annotation-driven>mvc:annotation-driven>
<mvc:resources location="/js/" mapping="/js/**">mvc:resources>
<mvc:resources location="/css/" mapping="/css/**">mvc:resources>
<mvc:resources location="/images/"
mapping="/images/**">mvc:resources>
beans>
@Controller
public class DemoController {
//请求映射，就是url有项目名/demo2
@RequestMapping("demo")
public String demo(){
System.out.println("执行 demo");
//返回值由内置的视图解析器进行解析
return "main.jsp";
}
@RequestMapping("demo2")
public String demo2(){
System.out.println("demo2");
return "main1.jsp";
}
}
传参
@Controller
public class DemoController {
@RequestMapping("demo")
//想要参数是什么类型，就直接在这里写。People类也可以
public String demo(String name,int age){
System.out.println("执行 demo"+" "+name+"
"+age);
//如果出现400错误，就是参数不能赋给属性，类型不匹配
return "main.jsp";
}
}
req.setAttribute(“demo123”,“测试”);
前端就可以${demo123}获取到值
@RequestMapping("demo")
public String demo(@RequestParam(value="name1")
String name,@RequestParam(value="age1")int age){
System.out.println("执行 demo"+" "+name+"
"+age);
return "main.jsp";
}
2.3.1 防止没有参数时 500 @RequestMapping("page")
public String page(@RequestParam(defaultValue="2")
int pageSize,@RequestParam(defaultValue="1") int
pageNumber){
System.out.println(pageSize+" "+pageNumber);
return "main.jsp";
}
@RequestMapping("demo2")
public String demo2(@RequestParam(required=true)
String name){
System.out.println("name 是 SQL 的查询条件,必须要传
递 name 参数"+name);
return "main.jsp";
}
7.2 在 jsp 中设定特定的格式 <a href="demo8/123/abc">跳转a>
7.3.1 在@RequestMapping 中一定要和请求格式对应
7.3.2 {名称} 中名称自定义名称
7.3.3 @PathVariable 获取@RequestMapping 中内容,默认按照
方法参数名称去寻找.@RequestMapping("demo8/{id1}/{name}")
public String demo8(@PathVariable String
name,@PathVariable("id1") int age){
System.out.println(name +"
"+age);
return "/main.jsp";
}
@RequestMapping("demo4")
public String demo4(People peo){
return "main.jsp";
}
@RequestMapping("demo5")
public String demo5(String name,int
age,@RequestParam("hover")List<String> abc){
System.out.println(name+" "+age+" "+abc);
return "main.jsp";
}
<input type="text" name="peo.name"/>
<input type="text" name="peo.age"/>
public class Demo {
private People peo;
控制器
@RequestMapping("demo6")
public String demo6(Demo demo){
System.out.println(demo);
return "main.jsp";
}
<input type="text" name="peo[0].name"/>
<input type="text" name="peo[0].age"/>
<input type="text" name="peo[1].name"/>
<input type="text" name="peo[1].age"/>
public class Demo {private List<People> peo;
控制器
@RequestMapping("demo6")
public String demo6(Demo demo){
System.out.println(demo);
return "main.jsp";
}
作用域传值
@RequestMapping("demo1")
public String demo1(HttpServletRequest
abc,HttpSession sessionParam){
//request 作用域
abc.setAttribute("req", "req 的值");
//session 作用域
HttpSession session = abc.getSession();
session.setAttribute("session", "session 的值");
sessionParam.setAttribute("sessionParam",
"sessionParam 的值");
//appliaction 作用域
ServletContext application =
abc.getServletContext();
application.setAttribute("application","application 的值");
return "/index.jsp";
}
2.2 spring 会对 map 集合通过 BindingAwareModelMap 进行实例化@RequestMapping("demo2")
public String demo2(Map<String,Object> map){
System.out.println(map.getClass());
map.put("map","map 的值");
return "/index.jsp";
}
@RequestMapping("demo3")
public String demo3(Model model){
model.addAttribute("model", "model 的值");
return "/index.jsp";
}
@RequestMapping("demo4")public ModelAndView demo4(){
//参数,跳转视图
ModelAndView mav = new ModelAndView("/index.jsp");
mav.addObject("mav", "mav 的值");
return mav;
}
文件下载
2.1 attachment 下载,以附件形式下载.
2.2 filename=值就是下载时显示的下载文件名
下载
@RequestMapping("download")
public void download(String
fileName,HttpServletResponse res,HttpServletRequest
req) throws IOException{
//设置响应流中文件进行下载
//这里filename=什么，下载到本地的文件名就是什么
res.setHeader("Content-Disposition",
"attachment;filename="+fileName);
//把二进制流放入到响应体中.
ServletOutputStream os = res.getOutputStream();
//获取到磁盘根目录下的路径
String path =
req.getServletContext().getRealPath("files");
System.out.println(path);
File file = new File(path, fileName);
//导入的jar包所封装的类
byte[] bytes =
FileUtils.readFileToByteArray(file);
os.write(bytes);
os.flush();
os.close();
}
文件上传
2.1 把客户端上传的文件流转换成 MutipartFile 封装类.
2.2 通过 MutipartFile 封装类获取到文件流
3.1 在的 enctype 属性控制表单类型
3.2 默认值 application/x-www-form-urlencoded,普通表单数据.(少 量文字信息)
3.3 text/plain 大文字量时使用的类型.邮件,论文
3.4 multipart/form-data 表单中包含二进制文件内容（这样表单才能上传文件流）
get最大2kb，字符流 <form action="upload" enctype="multipart/form-data"
method="post">
姓名:<input type="text" name="name"/><br/>
文件:<input type="file" name="file"/><br/>
<input type="submit" value="提交"/>
form>
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.Comm
onsMultipartResolver">
<property name="maxUploadSize"
value="50">property>
bean>
<bean id="exceptionResolver"
class="org.springframework.web.servlet.handler.Simple
MappingExceptionResolver">
<property name="exceptionMappings">
<props>
<prop
key="org.springframework.web.multipart.MaxUploadSizeE
xceededException">/error.jspprop>
props>
property>
bean>
@RequestMapping("upload")
public String upload(MultipartFile file,String name)
throws IOException{
String fileName = file.getOriginalFilename();
String suffix =
fileName.substring(fileName.lastIndexOf("."));
//判断上传文件类型
if(suffix.equalsIgnoreCase(".png")){
String uuid = UUID.randomUUID().toString();
FileUtils.copyInputStreamToFile(file.getInputStream
(), new File("E:/"+uuid+suffix));
return "/index.jsp";
}else{
return "error.jsp";
}
}
自定义拦截器
2.1 跟 AOP 区分开.AOP 在特定方法前后扩充(对 ServiceImpl)
2.2 拦截器,请求的拦截.针对点是控制器方法.(对 Controller)
3.1 拦截器只能拦截器 Controller
3.2 Filter 可以拦截任何请求.
public class DemoInterceptor implements
HandlerInterceptor {
//在进入控制器之前执行
//如果返回值为 false,阻止进入控制器
//控制代码
@Overridepublic boolean preHandle(HttpServletRequest arg0,
HttpServletResponse arg1, Object arg2) throws Exception
{
System.out.println("arg2:"+arg2);
System.out.println("preHandle");
return true;
}
//控制器执行完成,进入到 jsp 之前执行.
//日志记录.
//敏感词语过滤
@Override
public void postHandle(HttpServletRequest arg0,
HttpServletResponse arg1, Object arg2, ModelAndView
arg3)
throws Exception {
System.out.println("往"+arg3.getViewName()+"跳转
");
System.out.println("model 的值
"+arg3.getModel().get("model"));
String word =
arg3.getModel().get("model").toString();String newWord = word.replace("祖国", "**");
arg3.getModel().put("model", newWord);
//
arg3.getModel().put("model", "修改后的内容");
System.out.println("postHandle");
}
//jsp 执行完成后执行
//记录执行过程中出现的异常.
//可以把异常记录到日志中
@Override
public void afterCompletion(HttpServletRequest arg0,
HttpServletResponse arg1, Object arg2, Exception arg3)
throws Exception {
System.out.println("afterCompletion"+arg3.getMessag
e());
}
}
<mvc:interceptors>
<bean
class="com.bjsxt.interceptor.DemoInterceptor">bean>mvc:interceptors>
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/demo"/>
<mvc:mapping path="/demo1"/>
<mvc:mapping path="/demo2"/>
<bean
class="com.bjsxt.interceptor.DemoInterceptor">bean>
mvc:interceptor>
mvc:interceptors>
preHandle(A) --> preHandle(B) --> 控制器方法 --> postHandle(B) --> postHanle(A) --> JSP --> afterCompletion(B) --> afterCompletion(A)SpringMVC 对 Date 类型转换
1.2 时间类型 java.sql.Date<mvc:annotation-driven
conversion-service="conversionService">mvc:annotati
on-driven><bean id="conversionService"
class="org.springframework.format.support.Formattin
gConversionServiceFactoryBean">
<property name="registerDefaultFormatters"
value="false" />
<property name="formatters">
<set>
<bean
class="org.springframework.format.number.NumberForm
atAnnotationFormatterFactory" />
set>
property>
<property name="formatterRegistrars">
<set>
<bean
class="org.springframework.format.datetime.joda.Jod
aTimeFormatterRegistrar"><property name="dateFormatter">
<bean
class="org.springframework.format.datetime.joda.Dat
eTimeFormatterFactoryBean">
<property name="pattern"
value="yyyy-MM-dd" />
bean>
property>
bean>
set>
property>
bean>
@RequestMapping("demo")
public String
demo(@DateTimeFormat(pattern="yyyy-MM-dd") Date time){
System.out.println(time);
return "abc.jsp";
}
@RequestMapping("demo")
public String demo( Demo1 demo){
System.out.println(demo);
return "abc.jsp";
}
public class Demo1 {
@DateTimeFormat(pattern="yyyy/MM/dd")
private Date time;
2.3.1 不需要导入额外 jar
2.3.2 Date 是 java.util.DatejFinal
其他
RBAC
好的完成权限控制
4.1 菜单功能
4.2 url 控制(控制访问不同的控制器.)
4.3 资源可见性控制(页面某些元素对不同用户可见性是不同的 )JUnit
测试-------
黑盒
白盒，单元测试需要编码实现《单元测试之道》JUnit
JUnit使用--------
导入jar
@Test
断言Assert.assertEquals（期望值，实际值）shiro
相应的接口注入给 Shiro 即可。认证、 授权、加密、会话管理、与 Web 集成、缓存等
shiro的结构体系
常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用 户对某个资源是否具有某个权限；
会话可以是普通 JavaSE 环境的，也可以是如 Web 环境的；
Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率； 支持多种缓存架构，如ehcache。还支持缓存数据库，如redis.
Concurrency：shiro 支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能 把权限自动传播过去；
Testing：提供测试支持；
Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；
Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录
了。Shiro 架构
Subject 在 shiro 中是一个接口，接口中定义了很多认证授相关的方法，外部程序通过 subject 进行认证授，而 subject 是通过 SecurityManager 安全管理器进行认证授权.
负责对所有的 subject 进行安全管理。通过 SecurityManager 可以完成 subject 的认证、授权 等，实质上 SecurityManager 是通过 Authenticator 进行认证，通过 Authorizer 进行授权，通
过 SessionManager 进行会话管理等。
SecurityManager 是一个接口，继承了 Authenticator, Authorizer, SessionManager 这三个接 口
ModularRealmAuthenticator 实现类，通过 ModularRealmAuthenticator 基本上可以满足大多数需求，也可以自定义认证器
户是否有此功能的操作权限
securityManager 进行安全认证需要通过 Realm
获取用户权限数据，比如：如果用户身份数据在数据库那么 realm 就需要从数据库获取用户 身份信息。
sessionManager 即会话管理，shiro 框架定义了一套会话管理，它不依赖 web 容器的 session，
所以 shiro 可以使用在非 web 应用上，也可以将分布式应用的会话集中在一点管理，此特性 可使它实现 单点登录。
1.4.7 SessionDAO
SessionDAO 即会话 dao，是对 session 会话操作的一套接口，比如要将 session 存储到数据库,可以通过 jdbc 将会话存储到数据库。
1.4.8 CacheManager
CacheManager 即缓存管理，将用户权限数据存储在缓存，这样可以提高性能。
1.4.9 Cryptography
Cryptography 即密码管理，shiro 提供了一套加密/解密的组件，方便开发。比如提供常 用的散列、加 / 解密等功能。认证
环境搭建
log4j.rootLogger=debug, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n
[users]
zhangsan=1111
lisi=1111
//用户登录和退出
@Test
public void testAuthenticator(){
// 构建 SecurityManager 工厂，IniSecurityManagerFactory 可以从 ini 文件中初始化 SecurityManager 环境
Factory<SecurityManager> factory = new
IniSecurityManagerFactory("classpath:shiro.ini");
//通过工厂获得 SecurityManager 实例SecurityManager securityManager = factory.getInstance();
//将 securityManager 设置到运行环境中
SecurityUtils.setSecurityManager(securityManager);
//获取 subject 实例
Subject subject = SecurityUtils.getSubject();
//创建用户名,密码身份验证 Token 假装zhangsan在登陆
UsernamePasswordToken token = new
UsernamePasswordToken("zhangsan", "1111");
try {
//登录，即身份验证
//←将token委托给securityManager接口--通过
//DefaultsecurityManager中的login---login调用了该
//类的authenticate()---authenticate()调用了
//authenticator（认证器）--authenticator的默认
//modularRealmAuthticator中的doAuthenticate来获取
//realms信息，来完成认证工作。
subject.login(token);
} catch (AuthenticationException e) {
e.printStackTrace();
//身份认证失败
}
//断言用户已经登录
Assert.assertEquals(true, subject.isAuthenticated());
//退出
subject.logout();
}
自定义 Realm
最基础的是 Realm 接口(定义了根据token获取认证信息的方法)，CachingRealm 负责缓存处理，AuthenticationRealm 负责认证， AuthorizingRealm 负责授权，通常自定义的 realm 继承 AuthorizingRealm。(既身份认证又授权)
/**
* 自定义 Realm 实现
*/
public class UserRealm extends AuthorizingRealm {
@Override
public String getName() {
return "UserRealm";
}
//用于认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws
AuthenticationException {
//从 token 中获取身份信息
String username = (String)token.getPrincipal();
//根据用户名到数据库中取出用户信息 如果查询不到 返回 null
String password = "1111";//假如从数据库中获取密码为 1111
//返回认证信息
SimpleAuthenticationInfo simpleAuthenticationInfo = new
SimpleAuthenticationInfo(username, password, this.getName());
return simpleAuthenticationInfo;
}
//用于授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(
PrincipalCollection principals) {
return null;
}
}
[main]
#自定义 realmuserRealm=cn.siggy.realm.UserRealm
#将 realm 设置到 securityManager
securityManager.realms=$userRealm
散列算法
public class ShiroTest {
//shiro 提供了现成的加密类 Md5Hash
@Test
public void testMd5(){
//MD5 加密
String password = new Md5Hash("1111").toString();
System.out.println("加密后："+password);
//加盐 salt 默认一次散列
String password_salt=new Md5Hash("1111",
"siggy").toString();
System.out.println("加盐后："+password_salt);
//散列 2 次
String password_salt_2 = new Md5Hash("1111", "siggy",
2).toString();
System.out.println("散列 2 次："+password_salt_2);
//使用 SimpleHashSimpleHash hash = new SimpleHash("MD5", "1111", "siggy", 2);
System.out.println("simpleHash:"+hash.toString());
}
}
public class UserRealm extends AuthorizingRealm {
@Override
public String getName() {
return "UserRealm";
}
//用于认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws
AuthenticationException {
//从 token 中获取身份信息
String username = (String)token.getPrincipal();
//根据用户名到数据库中取出用户信息 如果查询不到 返回 null
//按照固定规则加密码结果 ，此密码 要在数据库存储，原始密码 是
1111，盐是 siggy 2 次散列
String password = "1620d20433da92e2523928e351e90f97";//假
如从数据库中获取密码为 1111
//返回认证信息
SimpleAuthenticationInfo simpleAuthenticationInfo = new
SimpleAuthenticationInfo(username,
password,
ByteSource.Util.bytes("siggy"),this.getName());
return simpleAuthenticationInfo;
}
//用于授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(
PrincipalCollection principals) {
return null;
}
}
[main]
#定义凭证匹配器
credentialsMatcher=org.apache.shiro.authc.credential.HashedCredentialsMatcher
#散列算法
credentialsMatcher.hashAlgorithmName=md5
#散列次数
credentialsMatcher.hashIterations=2
#将凭证匹配器设置到 realm
userRealm=cn.siggy.realm.UserRealm
userRealm.credentialsMatcher=$credentialsMatcher
securityManager.realms=$userRealm
[roles]定义在[users]中的角色与权限关联起来授权
权限安全策略中的原子授权单位，通过权限我们可以表示在应用中用户有没有操作某个资源的权力。即权限表示在应用中用户能不能访问某个资源，如：访问用户列表页面查看/新增/修
改/删除用户数据（即很多时候都是 CRUD（增查改删）式权限控制）打印文档等等。。。
细粒度：对记录的操作，如查询id=1的user的工资。
shiro一般管理的是粗粒度的权限。如菜单，按钮，url
细粒度权限一般是通过业务来控制的
资源:操作:实例，可以用通配符
user:add
user:delete:100 对user标识为100的记录有删除权限
1、首先调用 Subject.isPermitted*/hasRole接口，其会委托给 SecurityManager，而
SecurityManager 接着会委托给 Authorizer；
2、Authorizer 是真正的授权者，如果我们调用如 isPermitted(“user:view”)，其首先会通过
PermissionResolver 把字符串转换成相应的 Permission 实例；
3、在进行授权之前，其会调用相应的 Realm 获取 Subject 相应的角色/权限用于匹配传入的
角色/权限；
4、Authorizer 会判断 Realm 的角色/权限是否和传入的匹配，如果有多个 Realm，会委托给
ModularRealmAuthorizer 进行循环判断，如果匹配如 isPermitted/hasRole*会返回 true，否
则返回 false 表示授权失败。 Subject subject = SecurityUtils.getSubject();if(subject.hasRole(“
admin”)) {
//有权限
} else {
//无权限
}
@RequiresRoles("admin")
public void hello() {
//有权限
}
<shiro:hasRole name="admin">
<!— 有权限—>
shiro:hasRole>
[users]
zhangsan=1111,role1,role2
lisi=1111,role1
[roles]
role1=user:create,user:update
role2=user:create,user:delete
public class ShiroTest {
//用户登录和退出
@Test
public void testPermission(){
// 构建 SecurityManager 工厂，IniSecurityManagerFactory 可以
从 ini 文件中初始化 SecurityManager 环境
Factory<SecurityManager> factory = new
IniSecurityManagerFactory("classpath:shiro-permission.ini");
//通过工厂获得 SecurityManager 实例
SecurityManager securityManager = factory.getInstance();
//将 securityManager 设置到运行环境中
SecurityUtils.setSecurityManager(securityManager);
//获取 subject 实例
Subject subject = SecurityUtils.getSubject();
//创建用户名,密码身份验证 Token
UsernamePasswordToken token = new
UsernamePasswordToken("zhangsan", "1111");
try {
//登录，即身份验证
subject.login(token);
} catch (AuthenticationException e) {
e.printStackTrace();
//身份认证失败
}
// 用户认证状态
boolean isAuthenticated = subject.isAuthenticated();
System.out.println("用户认证状态：" + isAuthenticated);
//判断拥有角色：role1
Assert.assertTrue(subject.hasRole("role1"));
//判断拥有角色：role1 and role2
Assert.assertTrue(subject.hasAllRoles(Arrays.asList("role1"
, "role2")));
//判断拥有角色：role1 and role2 and !role3boolean[] result = subject.hasRoles(Arrays.asList("role1",
"role2", "role3"));
Assert.assertEquals(true, result[0]);
Assert.assertEquals(true, result[1]);
Assert.assertEquals(false, result[2]);
//判断拥有权限：user:create
Assert.assertTrue(subject.isPermitted("user:create"));
//判断拥有权限：user:update and user:delete
Assert.assertTrue(subject.isPermittedAll("user:update",
"user:delete"));
//判断没有权限：user:view
Assert.assertFalse(subject.isPermitted("user:view"));
}
}
public class UserRealm extends AuthorizingRealm {
@Override
public String getName() {
return "UserRealm";
}
//用于认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws
AuthenticationException {
//从 token 中获取身份信息String username = (String)token.getPrincipal();
//根据用户名到数据库中取出用户信息 如果查询不到 返回 null
String password = "1111";//假如从数据库中获取密码为 1111
//返回认证信息
SimpleAuthenticationInfo simpleAuthenticationInfo = new
SimpleAuthenticationInfo(username, password, this.getName());
return simpleAuthenticationInfo;
}
//用于授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(
PrincipalCollection principals) {
//获取身份信息
String username =
(String)principals.getPrimaryPrincipal();
//根据身份信息获取权限数据
//模拟
List<String> permissions = new ArrayList<String>();
permissions.add("user:save");
permissions.add("user:delete");
//将权限信息保存到 AuthorizationInfo 中
SimpleAuthorizationInfo simpleAuthorizationInfo = new
SimpleAuthorizationInfo();
for(String permission:permissions){
simpleAuthorizationInfo.addStringPermission(permission);
}
return simpleAuthorizationInfo;
}
}
[
main]
#自定义 realm
userRealm=cn.siggy.realm.UserRealm
#将 realm 设置到 securityManager
securityManager.realms=$userRealm
public class UserRealm extends AuthorizingRealm {
@Override
public String getName() {
return "UserRealm";
}
//用于认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws
AuthenticationException {
//从 token 中获取身份信息
String username = (String)token.getPrincipal();
//根据用户名到数据库中取出用户信息 如果查询不到 返回 null
String password = "1111";//假如从数据库中获取密码为 1111
//返回认证信息
SimpleAuthenticationInfo simpleAuthenticationInfo = new
SimpleAuthenticationInfo(username, password, this.getName());
return simpleAuthenticationInfo;
}
//用于授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(
PrincipalCollection principals) {
//获取身份信息
String username =
(String)principals.getPrimaryPrincipal();
//根据身份信息获取权限数据
//模拟
List<String> permissions = new ArrayList<String>();
permissions.add("user:save");
permissions.add("user:update");
permissions.add("user:delete");
//将权限信息保存到 AuthorizationInfo 中
SimpleAuthorizationInfo simpleAuthorizationInfo = new
SimpleAuthorizationInfo();
for(String permission:permissions){
simpleAuthorizationInfo.addStringPermission(permission);
}return simpleAuthorizationInfo;
}
}
shiro 与项目集成开发
整合 shiro
filter关联起来 --> <filter>
<filter-name>shiroFilterfilter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy
<init-param>
<param-name>targetFilterLifecycleparam-name>
<param-value>trueparam-value>
init-param>
<init-param>
<param-name>targetBeanNameparam-name>
<param-value>shiroFilterparam-value>
init-param>
filter>
<filter-mapping>
<filter-name>shiroFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
<bean id="shiroFilter"
class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager" />
<property name="loginUrl" value="/login.do" />
<property name="successUrl" value="/index.do"/>
<property name="unauthorizedUrl" value="/refuse.jsp" />
<property name="filterChainDefinitions">
<value>
/login.jsp=anon
/** = authc
value>
property>
bean>
<bean id="securityManager"
class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<property name="realm" ref="userRealm" />
bean>
<bean id="userRealm" class="cn.siggy.realm.UserRealm">
<property name="credentialsMatcher"
ref="credentialsMatcher"/>
bean>
<bean id="credentialsMatcher"
class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
<property name="hashAlgorithmName" value="md5" />
<property name="hashIterations" value="1" />
bean>
登录
org.apache.shiro.web.filter.mgt.DefaultFilter 中的过滤器：
authc:例如/admins/user/=authc 表示需要认证(登录)才能使用，FormAuthenticationFilter 是 表单认证，没有参数 使用 FormAuthenticationFilter 过虑器实现 ，原理如下：将用户没有认证时，请求 loginurl 进行认证，用户身份和用户密码提交数据到 loginurl
如果查询不到，realm 返回 null，FormAuthenticationFilter 向 request 域中填充一个 参数（记录了异常信息）
username 和
过滤器简称
对应的 java 类
anon
org.apache.shiro.web.filter.authc.AnonymousFilter
authc
org.apache.shiro.web.filter.authc.FormAuthenticationFilter
authcBasic
org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter
perms
org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter
port
org.apache.shiro.web.filter.authz.PortFilter
rest
org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter
roles
org.apache.shiro.web.filter.authz.RolesAuthorizationFilter
ssl
org.apache.shiro.web.filter.authz.SslFilter
user
org.apache.shiro.web.filter.authc.UserFilter
logout
org.apache.shiro.web.filter.authc.LogoutFilterpassword），修改页面的账号和密码 的 input 的名称为 username 和 password@Controller
public class LoginController {
@RequestMapping("/login.do")
public String login(HttpServletRequest req,Model model){
String exceptionClassName =
(String)req.getAttribute("shiroLoginFailure");
String error = null;
if(UnknownAccountException.class.getName().equals(exception
ClassName)) {
error = "用户名/密码错误";
} else
if(IncorrectCredentialsException.class.getName().equals(except
ionClassName))
{
error = "用户名/密码错误";
} else if(exceptionClassName != null) {
error = "其他错误：" + exceptionClassName;
}
model.addAttribute("error", error);
return "redirect:login.jsp";
}
}
Hibernate
将类名映射数据库的表名
将类的属性名映射为表的字段名
将类的属性类型映射为表的字段的数据类型
将对象的属性映射为表的记录环境搭建
<hibernate-configuration>
<session-factory>
<property
name="connection.driver_class">com.mysql.jdbc.Driverproperty>
<property
name="connection.url">jdbc:mysql://localhost:3306/hibernate4
<property name="connection.username">rootproperty>
<property name="connection.password">rootproperty>
<property
name="dialect">org.hibernate.dialect.MySQLDialectproperty>
session-factory>
hibernate-configuration>
推荐实现序列化
重写hashCode和equals public class User {
private int id;
private String name;private int age;
public User() {
}
}
<hibernate-mapping
package="cn.sxt.pojo">
<class name="User" table="t_user">
<id name="id">
<generator class="native"/>
id>
<property name="name"/>
<property name="age"/>
class>
hibernate-mapping>
public class Test {
public static void main(String[] args) {
//读取 src 下 hibernate.cfg.xml
Configuration cfg = new Configuration().configure();
//获取注册对象 4.3 的创建办法
//创建服务注册
ServiceRegistry registry = new
StandardServiceRegistryBuilder()
.applySettings(cfg.getProperties())
.build();
SessionFactory factory =
cfg.buildSessionFactory(registry);
//不是http的session
Session session = factory.openSession();
//保存数据
Transaction tx = session.beginTransaction();
User u = new User("张三",22);
session.save(u);
tx.commit();
session.close();
}
}
User user=(User)session.get(User.class,1);
配置文件讲解
<hibernate-configuration>
<session-factory>
<property name="connection.driver_class">
com.mysql.jdbc.Driver
property>
<property name="connection.url">
jdbc:mysql:///hibernate4
property>
<property name="connection.username">rootproperty>
<property name="connection.password">rootproperty>
<property name="dialect">
org.hibernate.dialect.MySQL5Dialect
property>
<property name="show_sql">trueproperty>
<property name="format_sql">trueproperty>
<property name="hbm2ddl.auto">updateproperty>
<mapping resource="cn/sxt/pojo/User.hbm.xml"/>
session-factory>
hibernate-configuration>
<hibernate-mapping>
<class name="cn.sxt.pojo.User" table="t_user">
<id name="id" column="id">
<generator class="identity">
generator>
id>
<property name="name" length="40"/>
<property name="age" />
class>
hibernate-mapping>
hibernate 对象生命周期
a) 临时状态/瞬时状态
该对象是新创建的；一个持久化状态的对象被删除；一个游离状态的数据被删除
b) 持久化状态
对象从数据库中查询出来时，临时状态的数据被保存时，游离状态的数据被更新/ 锁定
c) 游离状态
持久化状态的数据被（session）清理
临时状态：内存有，数据库没有
持久状态：内存有,session 有，数据库有
游离状态：内存有，数据有Struts2
环境搭建
<filter>
<filter-name>struts2filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.Stru
tsPrepareAndExecuteFilterfilter-class>
filter>
<filter-mapping>
<filter-name>struts2filter-name>
<url-pattern>/*url-pattern>
filter-mapping>
public class HelloAction {
public String execute(){
System.out.println("hello struts2");
return "success";
}
}
在 servlet 中，service 方法参数时 HttpServletRequest 和 HttpServletResponse,无返回 值。在 struts2 中，方法都是 public 的，并且返回值都是 String 类型，而且方法都是没 有参数的。
Struts2 是基于包管理的。
<package name="hello" extends="struts-default">
<action name="hello" class="cn.sxt.action.HelloAction">
<result name="success">/index.jspresult>
action>
package>
http://localhost:8080/02struts2_hello/hello
服务器，服务器对浏览器进行相应的响应。简介
Model1 开发模式，在 jsp 内嵌 javaBean 代码。好处 是执行效率比较高。在项目规模比较大的时候，代码非常乱，维护起来非常麻烦。不利于分 工，也不利于代码的重用。Model2 即MVC 将代码分为了 3 块，视图 View,模型 Model, 控制器 Controller。内容和显示进行分离，开发人员可以专注于某一块，从而提高效率。适 合的项目规模比较大的情况。而且重复利用率得到提高，便于维护。
struts2是轻量级的mvc框架
轻量级：该框架没有侵入性
侵入性：如果使用一个框架，必须实现框架提供的接口，或继承框架提供的类，就是 有侵入性。
Servlet 做哪些事情：
处理用户提交的数据
调用业务方法
处理业务结果
控制视图显示
用户请求映射到一个 java 类。
将用户请求映射到一个 java 类。
获取用户提交的数据
渲染数据（将数据封装到前台显示（
request））
控制视图跳转
每次请求都会重新创建新的 action 对象，所以线程安全。
由于 action 对象是 struts2，反射生成的，所以要求 Action 类要有一个公共的无参构造 方法。
1.一样的话就是首 次提交。然后清除session中的token值。
2.如果 session中没有这个token值，那就是重复提交。
<script type="text/javascript"
src="js/jquery-1.11.3.js">script>
<script type="text/javascript">
$(function(){
$('#btn').click(function(){
$.post("ajax.action",function(data){
$('#msg').html(data);
});
});
});
script>
head>
<body>
<input type="button" id="btn" value="获取 ajax 信息"/>
<h3 id="msg">h3>
body>
public class AjaxAction {
public String execute() throws IOException{
HttpServletResponse resp =
ServletActionContext.getResponse();
resp.setCharacterEncoding("utf-8");
resp.getWriter().print("struts ajax");
return null;
}
}
<package name="default" extends="list-default" namespace="/">
<action name="ajax" class="cn.sxt.action.AjaxAction">
action>
package>
ezmorph-1.0.6.jar
struts2-json-plugin-2.2.1.jar
json-lib-2.1-jdk15.jar
public class JsonAction {
private JSONArray root;public String execute(){
List<User> list = new ArrayList<User>();
list.add(new User("siggy",23));
list.add(new User("zhangsan",22));
list.add(new User("老王",21));
root = JSONArray.fromObject(list);
System.out.println("json="+root.toString());
return "success";
}
public JSONArray getRoot() {
System.out.println("获取 root 数据");
return root;
}
public void setRoot(JSONArray root) {
this.root = root;
}
}
<script type="text/javascript"
src="js/jquery-1.11.3.js">script>
<script type="text/javascript">
$(function(){
$('#btn').click(function(){
$.post("json.action",function(data){
var html="";
for(var i=0;i<data.length;i++){
html+=""+data[i].name+" "+data[i].age+"</td
></tr>";
}
$('#content').html(html);
},'json');
});
});
script>
head>
<body>
<input type="button" id="btn" value="获取 json 数据"/>
<table width="80%" align="center">
<tr>
<td>姓名td><td>年龄td>
tr>
<tbody id="content">
tbody>
table>
body>
<package name="default" extends="json-default" namespace="/">
<action name="json" class="cn.sxt.action.JsonAction">
<result type="json">
<param name="root">rootparam>
result>
action>
package>
配置文件
<constant name="struts.i18n.encoding" value="UTF-8"/>
<constant name="struts.action.extension"
value="action,,siggy"/>
<constant name="struts.devMode" value="true"/>
<constant name="struts.configuration.xml.reload" value="true"/>
<include file="config/sxt/struts/user.xml"/>
<package name="user" namespace="/user" extends="struts-default">
<action name="login" class="cn.sxt.action.LoginAction">
配置不写method
调用处理方法actionName!methodNmae.action
<result type="redirectAction">logoutresult>
- struts2默认提供了五种返回结果，success,none,error,input,login
<global-results>
<result name="login">/login.jspresult>
global-results>
<default-action-ref name="default"/>
<default-class-ref class="cn.sxt.action.AddAction"/>
<action name="user*" class="cn.sxt.action.AddAction"
method="{1}">
<result>/index.jspresult>
action>
Action 的实现方式
public class PojoAction {
public String execute(){
System.out.println("pojo action");
return "success";
}
}
可以直接使用action提供的常量 public class InterfaceAction implements Action{
public String execute() throws Exception {
System.out.println("interface action");
return SUCCESS;
}
}
public class ExtendsAction extends ActionSupport{
@Override
public String execute() throws Exception {
System.out.println("extends action");
return SUCCESS;
}
}
获取表单数据
如果数据需要显示到页面上，那么该数据可以作为处理类的属性，处理方法后该属性有值，且有该属性的get方法，那么在页面上可以直接通过el表达式获取。
由主动编程，变为被动编程。ioc 值由框架获得，赋值
<form action="register.action" method="post">
用户名:<input type="text" name="user.name" /><br>
密码:<input type="password" name="user.pwd" /><br>
年龄:<input type="text" name="user.age" /><br>
邮箱:<input type="text" name="user.email" /><br>
<input type="submit" value="提交" />
form>
public class UserAction {
//对象声明即可
private User user;
//注册
public String register(){
System.out.println(user);
return Action.SUCCESS;
}
//框架通过反射 class的newinstance创建 对象。所以要有无
//参构造
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
public class User {
private String name;
private String pwd;
private int age;
private String email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public int getAge() {return age;
}
public void setAge(int age) {
this.age = age;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "User [name=" + name + ", pwd=" + pwd + ", age=" +
age
+ ", email=" + email + "]";
}
}
<package name="user" extends="struts-default">
<action name="register"
class="cn.sxt.action.UserAction" method="register">
<result name="success">/show.jspresult>
action>
package>
<form action="regDriven.action" method="post">
用户名:<input type="text" name="name" /><br>
密码:<input type="password" name="pwd" /><br>
年龄:<input type="text" name="age" /><br>
邮箱:<input type="text" name="email" /><br>
<input type="submit" value="提交" />
form>
public class UserDrivenAction implements ModelDriven<User>{private User user = new User();
//注册
public String register(){
System.out.println(user);
return Action.SUCCESS;
}
public User getModel() {
return user;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
public class User {
private String name;
private String pwd;
private int age;
private String email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getEmail() {
return email;
}public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "User [name=" + name + ", pwd=" + pwd + ", age=" +
age
+ ", email=" + email + "]";
}
}
<package name="user" extends="struts-default">
<action name="register" class="cn.sxt.action.UserAction"
method="register">
<result name="success">/show.jspresult>
action>
<action name="regDriven"
class="cn.sxt.action.UserDrivenAction" method="register">
<result name="success">/show.jspresult>
action>
package>
String strAge = req.getParameter("age");
int age=0;
if(strAge!=null){
age=Integer.parseInt(strAge);
}
型转换器来进行类型转换。
<body>
<form action="point.action" method="post">
x:<input type="text" name="point.x"/><br>
y:<input type="text" name="point.y"/><br>
<input type="submit" value="提交"/>
form>
body>
public class PointAction {
private Point point;
public String execute(){
System.out.println(point.getX()+"-----"+point.getY());
return Action.SUCCESS;
}
public Point getPoint() {
return point;
}
public void setPoint(Point point) {
this.point = point;
}
}
<package name="default" namespace="/" extends="struts-default">
<action name="point" class="cn.sxt.action.PointAction">
<result>/index.jspresult>
action>
package>
public class PointConverter extends StrutsTypeConverter{
/**
* 将表单提交的字符串数据 转换为 指定自定义类型
* context 是 ActionContext
* values 要进行类型转换的字符串数组
* toClass 被转换的类型
* */
@Override
public Object convertFromString(Map context, String[] values,
Class toClass) {
String value=values[0];
Point point = new Point();
String x = value.substring(1,value.indexOf(","));
String
y=value.substring(value.indexOf(",")+1,value.length()-1);
System.out.println("x="+x);
System.out.println("y="+y);
point.setX(Integer.parseInt(x));
point.setY(Integer.parseInt(y));
return point;
}
/**
* 将定义类型 转换为字符串在前台页面显示----通过 ognl 表达式将会使
用该方法进行转换
* context ---actionContext
* o 要转换的对象
* */
@Override
public String convertToString(Map context, Object o) {
Point point = (Point)o;
return "("+point.getX()+","+point.getY()+")";
}}
cn.sxt.entity.Point=cn.sxt.converter.PointConverter
Action 代码不变，struts.xml 配置不变
Jsp 页面 <form action="point.action" method="post">
点:<input type="text" name="point"/><br>
<input type="submit" value="提交"/>
form>
获取 ServletAPI
action—>service—>dao
ActionContext.getContext().getSession().put("user", name);
//处理方法
public String execute(){
System.out.println(name+"---"+pwd);
if("siggy".equals(name)&&"1111".equals(pwd)){
//获取 session
ActionContext.getContext().getSession().put("user",
name);
//获取 request---HttpServletRequest 对象的 attributes
Map<String,Object> request =
(Map)ActionContext.getContext().get("request");
//获取 application
Map<String,Object>
application=ActionContext.getContext().getApplication();
//获取 parameters
Map<String,Object> parameters =
ActionContext.getContext().getParameters();
//相当于 request.getParameter("name");
System.out.println("name===="+((String[])parameters.get("na
me"))[0]);
return "success";
}else{
return "login";
}
}
//处理方法
public String execute(){
System.out.println(name+"---"+pwd);
if("siggy".equals(name)&&"1111".equals(pwd)){
HttpServletRequest
request=(HttpServletRequest)ActionContext.getContext().get(Str
utsStatics.HTTP_REQUEST);
request.getSession().setAttribute("user", name);System.out.println("name===="+request.getParameter("name"))
;
return "success";
}else{
return "login";
}
}
实现 ServletRequestAware 接口 public class LoginAction2 implements ServletRequestAware{
private String name;
private String pwd;
HttpServletRequest request;
//处理方法
public String execute(){
System.out.println(name+"---"+pwd);
if("siggy".equals(name)&&"1111".equals(pwd)){
request.getSession().setAttribute("user", name);
System.out.println("name===="+request.getParameter("name"))
;
return "success";
}else{
return "login";
}
}
public void setServletRequest(HttpServletRequest request) {
this.request=request;
}
public String logout(){
ActionContext.getContext().getSession().remove("user");
System.out.println("退出");
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {this.pwd = pwd;
}
}
public String execute(){
System.out.println(name+"---"+pwd);
if("siggy".equals(name)&&"1111".equals(pwd)){
HttpServletRequest request =
ServletActionContext.getRequest();
request.getSession().setAttribute("user", name);
System.out.println("name===="+request.getParameter("name"))
;
return "success";
}else{
return "login";
}
}
ActionContext
servlet不是线程安全的（处理多个请求 public static void main(String[] args) {
//ThreadLocal 存放线程局部变量的容器
//存放在 threadlocal 中的局部变量 是线程安全的
final ThreadLocal<String> ac = new ThreadLocal<String>();
ac.set("siggy");
new Thread(new Runnable(){
public void run() {System.out.println("thread:"+ac.get());
}
}).start();
System.out.println(ac.get());
}
法获取的，所以在本线程中的非 Action 类中 也可以直接访问。
ActionContext 对象的。如：filter 的 init()方法。
session
request ：存放的是httpservletrequest域中的数据
parameters ：请求参数
attr(page–>request—>session—>application) 从数据域一个个取
ValueStack(值栈)：业务处理类的相关数据
1.setAttribute即域
2.请求
Struts2 中值栈存放的数据是 Action 对象
OGNL 全称是 Object-Graph Navigation Language(对象图形导航语言)，相对于 EL 语 言，除了保持 EL 语言的优点外，他的其他优点如下：
能够访问对象的普通方法
能够访问类的静态属性和静态方法
强大的操作集合类对象的能力
支持赋值操作和表达式串联
访问 OGNL 上下文和 ActionContext
public static void main(String[] args) throws OgnlException {
//ognl思想：原则：数据分为 2 类 ---常用的和不常用的---常用的一般是小数据，
//不常用的一般是大数据
//表达式：常用的数据直接取，不常用的数据加#取
Map<String,Object> map=new HashMap<String,Object>();
map.put("name", "张三疯");
map.put("age", 125);
User user = new User();
user.setName("lisi");
//表达式，上下文（不常用的数据，ognl表达式的根（常用数据
Object obj = Ognl.getValue("#name", map, user);
System.out.println(obj);
}
valuestack做ognl的根对象
在 jsp 中导入 struts2 标签库: <%@ taglib prefix="s" uri="/struts-tags"%>
Struts2 推荐不直接访问 jsp 页面，推荐使用 action 来控制。 <%@ page language="java" import="java.util.*"
pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<%
String path = request.getContextPath();
String basePath =
request.getScheme()+"://"+request.getServerName()+":"+request. getServerPort()+path+"/";
%>
DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'index.jsp' starting pagetitle>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords"
content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
head>
<body>
用户名:<s:property value="name"/>【action 中的属性】<br>
用户名:<s:property
value="#session.user"/>-----------------<a
href="logout.action">退出a>
body>
html>
验证机制
1.js前端校验
2.后端数据校验
1.硬编码实现
2.校验框架实现
action需继承actionsupport类—提供了validate方法，可将验证规则卸载该方法，只由该方法执行通过后，才会执行业务方法。
一定要加上<s:actionerror/>或者是<s:fielderror/>
<s:actionerror/>
<form action="register.action" method="post">
用户名:<input type="text" name="name"/><br>
密码:<input type="password" name="pwd"/><br>
年龄:<input type="text" name="age"/><br>
生日:<input type="text" name="birthday"/><br>
<input type="submit" value="登录"/>
form>
public class RegisterAction extends ActionSupport{
private String name;
private String pwd;
private int age;
private Date birthday;
@Override
public String execute() throws Exception {
System.out.println("execute");
return Action.SUCCESS;
}
public String register(){
request
validateXxx 方法
validate 方法
xxx 方法
T
T
Result
F: input
reqpsonseSystem.out.println("register");
return Action.SUCCESS;
}
public void validateRegister(){
System.out.println("validate age");
if(age>100||age<1){
//在validate方法中，添加了fielderror或actionerror那么该方
//法将执行不能通 过，并且返回的结果集为INPUT
this.addActionError("年龄不合法");
}
}
public void validate() {
System.out.println("validate");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
<package name="default" extends="struts-default" namespace="/">
<action name="register"
class="cn.sxt.action.RegisterAction" method="register">
<result>/index.jspresult>
<result name="input">/register.jspresult>action>
package>
<s:fielderror>s:fielderror>
<form action="register.action" method="post">
用户名:<input type="text" name="name"/><br>
密码:<input type="password" name="pwd"/><br>
年龄:<input type="text" name="age"/><br>
生日:<input type="text" name="birthday"/><br>
<input type="submit" value="登录"/>
form>
public class RegisterValidateAction extends ActionSupport{
private String name;
private String pwd;
private int age;
private Date birthday;
@Override
public String execute() throws Exception {
System.out.println("execute");
return Action.SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
<package name="default" extends="struts-default" namespace="/">
<action name="register"
class="cn.sxt.action.RegisterValidateAction">
<result>/index.jspresult>
<result name="input">/register.jspresult>
action>
package>
DOCTYPE validators PUBLIC "-//Apache Struts//XWork Validator
1.0.3//EN"
"http://struts.apache.org/dtds/xwork-validator-1.0.3.dtd">
<validators>
<field name="name">
<field-validator type="requiredstring">
<param name="trim">trueparam>
<message>用户名必填message>
field-validator>
<field-validator type="stringlength">
<param name="trim">trueparam>
<param name="maxLength">10param>
<param name="minLength">4param>
<message>用户名去掉 2 端空格后 长度为${minLength}到
${maxLength}message>
field-validator>
field>
<field name="age">
<field-validator type="int"><param name="min">1param>
<param name="max">150param>
<message>年龄范围为 1~150message>
field-validator>
field>
validators>
拦截器
拦截器是单例的，所有action共享相同的 拦截器，所有拦截器定义常量时需要注意 线程安全问题。
1.实现interceptor
2.继承abstractinterceptor /***
*计算 action 执行时间
*/
public class TimeInterceptor extends AbstractInterceptor{
@Override
public String intercept(ActionInvocation invocation) throws
Exception {
long start=System.currentTimeMillis();
//执行下一个拦截器，当拦截器执行完后执行 action
String result= invocation.invoke();
long end=System.currentTimeMillis();
System.out.println("执行该 Action 所用时间为：
"+(end-start)+"ms");
return result;
}}
<struts>
<package name="default" extends="struts-default"
namespace="/">
<interceptors>
<interceptor name="time"
class="cn.sxt.interceptor.TimeInterceptor"/>
interceptors>
<action name="hello" class="cn.sxt.action.HelloAction">
<result>/index.jspresult>
<interceptor-ref name="time"/>
action>
package>
struts>
如果不引用拦截器，那么默认的拦截器将起作用。 <default-interceptor-ref name="defaultStack"/>
<action name="hello" class="cn.sxt.action.HelloAction">
<result>/index.jspresult>
<interceptor-ref name="time"/>
<interceptor-ref name="defaultStack"/>
action>
当 action 引用的拦截器个数比较多时，可以将多个拦截器放入一个拦截器栈中。
<interceptor-stack name="myStack">
<interceptor-ref name="time"/>
<interceptor-ref name="defaultStack"/>
interceptor-stack>
<action name="hello" class="cn.sxt.action.HelloAction">
<result>/index.jspresult>
<interceptor-ref name="myStack"/>
action>
<default-interceptor-ref name="myStack"/>
<action name="hello" class="cn.sxt.action.HelloAction">
<result>/index.jspresult>
action>
public class LoginInterceptor extends AbstractInterceptor{
@Override
public String intercept(ActionInvocation invocation) throws
Exception {
//判断是否是 login.action 如果是则直接执行下一个拦截器
//如果不是 则判断是否登录，如果登录执行下一个拦截器
//如果没有则返回登录页面
//actionName 没有扩展名
String actionName=invocation.getProxy().getActionName();
if("login".equals(actionName)){
return invocation.invoke();
}
Object obj =
invocation.getInvocationContext().getSession().get("user");
if(obj==null){//没有登录
return Action.LOGIN;
}
return invocation.invoke();
}
}
<struts>
<package name="default" extends="struts-default"
namespace="/">
<interceptors>
<interceptor name="time"
class="cn.sxt.interceptor.TimeInterceptor"/>
<interceptor name="loginInterceptor"
class="cn.sxt.interceptor.LoginInterceptor"/>
<interceptor-stack name="myStack">
<interceptor-ref name="loginInterceptor"/>
<interceptor-ref name="time"/>
<interceptor-ref name="defaultStack"/>
interceptor-stack>
interceptors>
<default-interceptor-ref name="myStack"/>
<global-results>
<result name="login">/login.jspresult>
global-results>
<action name="hello" class="cn.sxt.action.HelloAction">
<result>/WEB-INF/index.jspresult>
action>
<action name="login" class="cn.sxt.action.LoginAction">
<result>/success.jspresult>
action>
package>
struts>
<body>
<form action="user/login.action" method="post">
用户名:<input type="text" name="name"/><br>
密码:<input type="password" name="pwd"/><br>
<input type="submit" value="登录"/>
form>
body>
public class LoginAction {private String name;
private String pwd;
//处理方法
public String execute(){
System.out.println(name+"---"+pwd);
if("siggy".equals(name)&&"1111".equals(pwd)){
ActionContext.getContext().getSession().put("user",
name);
return "success";
}else{
return "login";
}
}
public String logout(){
System.out.println("退出");
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
截器一致。但是方法拦截器时继承 MethodFilterInterceptor 类，重写 doIntercept()方法。
引用方法拦截器配置会发生改变： <interceptor-ref name="methodInterceptor">
<param name="includeMethods">list,addparam>
<param name="excludeMethods">loginparam>
interceptor-ref>
文件操作
<form action="upload.action" method="post"
enctype="multipart/form-data">
文件:<input type="file" name="file"/>
<input type="submit" value="上传"/>
form>
两个分别是表单域名+FileName,表单域名+ContentType；并且提供 get/set 方法 public class UploadAction extends ActionSupport{
private File file;
//文件名
private String fileFileName;
//文件的类型
private String fileContentType;
//上传
public String upload() throws IOException{
//写文件的过程
HttpServletRequest request =
ServletActionContext.getRequest();
String path=request.getRealPath("/upload");
InputStream is = new FileInputStream(file);
OutputStream os = new FileOutputStream(new
File(path,fileFileName));
byte[] buffer = new byte[200];
int len=0;
while((len=is.read(buffer))!=-1){
os.write(buffer, 0, len);
}
os.close();
is.close();
return Action.SUCCESS;
}
public File getFile() {
return file;
}
public void setFile(File file) {
this.file = file;
}
public String getFileFileName() {
return fileFileName;}
public void setFileFileName(String fileFileName) {
this.fileFileName = fileFileName;
}
public String getFileContentType() {
return fileContentType;
}
public void setFileContentType(String fileContentType) {
this.fileContentType = fileContentType;
}
}
<struts>
<constant name="struts.multipart.saveDir" value="c:\"/>
<constant name="struts.multipart.maxSize" value="20971520"/>
<package name="default" extends="struts-default"
namespace="/">
<action name="upload" class="cn.sxt.action.UploadAction"
method="upload">
<result>/index.jspresult>
<interceptor-ref name="fileUpload">
<param name="maximumSize">20971520param>
interceptor-ref>
<interceptor-ref name="defaultStack"/>
action>
package>
struts>
<style type="text/css">
p{margin:5px;}
style>
<script type="text/javascript"
src="js/jquery-1.11.3.js">script>
<script type="text/javascript">
$(function(){
$('#btn').click(function(){var field="<p><input type='file'
name='file'/><input type='button' value='删除'
onclick='removed(this);'/></p>";
$('#files').append(field);
});
});
function removed(o){
$(o).parent().remove();
}
script>
head>
<body>
<form action="batch.action" method="post"
enctype="multipart/form-data">
文件:<input type="file" name="file"/><input
type="button" id="btn" value="添加"/>
<div id="files">div>
<input type="submit" value="上传"/>
form>
body>
public class BatchUploadAction {
private File[] file;
private String[] fileFileName;
private String[] fileContentType;
public String execute() throws IOException{
//写文件的过程
HttpServletRequest request =
ServletActionContext.getRequest();
String path=request.getRealPath("/upload");
for(int i=0;i<file.length;i++){
InputStream is = new FileInputStream(file[i]);
OutputStream os = new FileOutputStream(new
File(path,fileFileName[i]));
byte[] buffer = new byte[200];
int len=0;
while((len=is.read(buffer))!=-1){
os.write(buffer, 0, len);
}os.close();
is.close();
}
return Action.SUCCESS;
}
public File[] getFile() {
return file;
}
public void setFile(File[] file) {
this.file = file;
}
public String[] getFileFileName() {
return fileFileName;
}
public void setFileFileName(String[] fileFileName) {
this.fileFileName = fileFileName;
}
public String[] getFileContentType() {
return fileContentType;
}
public void setFileContentType(String[] fileContentType) {
this.fileContentType = fileContentType;
}
}
<action name="batch" class="cn.sxt.action.BatchUploadAction">
<result>/index.jspresult>
<interceptor-ref name="fileUpload">
<param name="maximumSize">20971520param>
interceptor-ref>
<interceptor-ref name="defaultStack"/>
action>
使用 HttpServletResponse 来实现，和以前 Servlet 中文件下载的方式一致。注意 在 action 执行方法中 返回 null;
public class DownloadAction {
public String execute() throws IOException{
HttpServletRequest req=ServletActionContext.getRequest();
HttpServletResponse resp =
ServletActionContext.getResponse();
//获取路径
String path=req.getRealPath("/download");
File file = new File(path,"Struts2.chm");
resp.setContentLength((int)file.length());
resp.setCharacterEncoding("utf-8");
resp.setContentType("application/octet-stream");
resp.setHeader("Content-Disposition",
"attachment;filename=Struts2.chm");
byte[] buffer = new byte[400];
int len=0;
InputStream is = new FileInputStream(file);
OutputStream os = resp.getOutputStream();
while((len=is.read(buffer))!=-1){
os.write(buffer, 0, len);
}
os.close();
is.close();
return null;
}
}
<package name="default" namespace="/" extends="struts-default">
<action name="download"
class="cn.sxt.action.DownloadAction">
action>
package>
<body>
<a href="download.action">struts2 的文档a>
body>
public class StreamDownloadAction {
private String fileName;
public String execute(){
return Action.SUCCESS;
}
public InputStream getInputStream() throws
FileNotFoundException{
HttpServletRequest req=ServletActionContext.getRequest();
//获取路径
String path=req.getRealPath("/download");
return new FileInputStream(new File(path,fileName));
}
public String getFileName() {
return fileName;
}
public void setFileName(String fileName) {
this.fileName = fileName;
}
}
<action name="streamDownload"
class="cn.sxt.action.StreamDownloadAction">
<result type="stream">
<param name="inputName">inputStreamparam>
<param
name="contentDisposition">attachment;filename=${fileName}par
am>
result>
action>
<body>
<a
href="streamDownload.action?fileName=Struts2.chm">struts2 的文档
a>
<a
href="streamDownload.action?fileName=Struts1.3.chm">struts1 的文档a>
body>
你可能感兴趣的:(java,代码审计,java,开发语言,后端)