ssh中自定义监听器,拦截器,过滤器
路由器SSH配置详解
Cisco路由器的SSH配置详解Cisco路由器的SSH配置详解如果你一直利用Telnet控制网络设备，你可以考虑采用其他更安全的方式。
本文告诉你如何用SSH替换Telnet.使用Telnet这个用来访问远程计算机的TCP/IP协议以控制你的网络设备相当于在离开某个建筑时大喊你的用户名和口令。
很快地，会有人进行监听，并且他们会利用你安全意识的缺乏。
SSH是替代Telnet和其他远程控制台管理应用程序的行业标准。
SSH命令是加密的并以几种方式进行保密。
在使用SSH的时候，一个数字证书将认证客户端（你的工作站）和服务器（你的网络设备）之间的连接，并加密受保护的口令。
SSH1使用RSA加密密钥，SSH2使用数字签名算法（DSA）密钥保护连接和认证。
加密算法包括Blowfish，数据加密标准（DES），以及三重DES（3DES）。
SSH保护并且有助于防止欺骗，“中间人”攻击，以及数据包监听。
实施SSH的第一步是验证你的设备支持SSH.请登录你的路由器或交换机，并确定你是否加载了一个支持SSH的IPSec IOS镜像。
在我们的例子中，我们将使用Cisco IOS命令。
运行下面的命令：Router> Show flash该命令显示已加载的IOS镜像名称。
你可以用结果对比你的供应商的支持特性列表。
在你验证了你的设备支持SSH之后，请确保设备拥有一个主机名和配置正确的主机域，就像下面的一样：Router> config terminalRouter (config)# hostname RouterRouter (config)# ip domain-name 在这个时候，你就可以启用路由器上的SSH服务器。
要启用SSH服务器，你首先必须利用下面的命令产生一对RSA密钥：Router (config)# crypto key generate rsa在路由器上产生一对RSA密钥就会自动启用SSH.如果你删除这对RSA密钥，就会自动禁用该SSH服务器。
SSH全注解
SSH全注解1、创建web工程，添加SSH支持注意：需要勾上Enable Hibernate Annotations Support2、修改xml配置文件 1）添加上下文参数2）添加监听器3）配置openSessionInView过滤器代码清单如下3、配置applicationContext.xml 1)添加命名空间2）添加注解支持以及包浏览3）配置spring事务管理器4) 配置annotation-driven5)配置hibernateTemplate模板4、删除冲突包antlr2.7.2.jar5、生成pojo类6、编写dao7、编写biz8、编写action实现接口@Repository("empDao")publicclass CommonDaoImpl<T>implements ICommonDao<T> {//定义hibernate模板private HibernateTemplate hibernateTemplate;@Resourcepublicvoid setHibernateTemplate(HibernateTemplate hibernateTemplate) {this.hibernateTemplate = hibernateTemplate;}@Overridepublic List<T> list(String hql) {returnthis.hibernateTemplate.find(hql);}@Overridepublic Serializable save(T t) {returnthis.hibernateTemplate.save(t);}@Overridepublicvoid delete(T o) {this.hibernateTemplate.delete(o);}@Overridepublic T get(Class<T> clazz, Serializable id) {returnthis.hibernateTemplate.get(clazz, id);}@Overridepublicvoid update(T o) {this.hibernateTemplate.update(o);}业务接口publicinterface IEmpBiz {public List<Emp> findEmpAll();/*** 增加员工的方法*/publicboolean addEmp(Emp emp);/*** 删除用户* @param empno* @return*/publicboolean removeEmp(short empno);/*** 按员工编号查询员工信息* @param empno* @return*/public Emp findEmpById(short empno);/*** 修改员工信息* @param emp* @return*/publicboolean updateEmp(Emp emp);实现业务接口@Service("empBiz")@Transactionalpublicclass EmpDaoImpl implements IEmpBiz {private ICommonDao<Emp>empDao;@Resourcepublicvoid setEmpDao(ICommonDao<Emp> empDao) {this.empDao = empDao;}@Override@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)public List<Emp> findEmpAll() {returnthis.empDao.list("from Emp");}@Overridepublicboolean addEmp(Emp emp) {Serializable id=this.empDao.save(emp);if(id!=null){returntrue;}returnfalse;}@Transactional(rollbackFor=ng.Exception.class,propagation=Pro pagation.REQUIRED)publicboolean removeEmp(short empno) {Emp emp=this.empDao.get(Emp.class,empno);try {this.empDao.delete(emp);returntrue;} catch (Exception e) {e.printStackTrace();}returnfalse;}@Transactional(propagation=Propagation.NOT_SUPPORTED)@Overridepublic Emp findEmpById(short empno) {returnthis.empDao.get(Emp.class,empno);}@Transactional(rollbackFor=ng.Exception.class,propagation=Pro pagation.REQUIRED)@Overridepublicboolean updateEmp(Emp emp) {try {this.empDao.update(emp);returntrue;} catch (Exception e) {e.printStackTrace();}returnfalse;}List.jsp页面<script type="text/javascript">function deleteMe(id){if(window.confirm("您确定要删除吗?")){window.location.href="deleteEmp?emp.empno="+id;}}function updateMe(id){window.location.href="prepUpdateEmp?emp.empno="+id;}</script><body><a href="preAddEmp">增加员工</a><table border="1"cellpadding="5"cellspacing="0"width="100%"> <tr><td>编号</td><td>姓名</td><td>职位</td><td>工资</td><td>入职日期</td><td>所属部门</td><td>操作</td></tr><s:if test="emps!=null"><s:iterator var="emp"value="emps"><tr><td><s:property value="#emp.empno"/></td><td><s:property value="#emp.ename"/></td><td><s:property value="#emp.job"/></td><td><s:property value="#emp.sal"/></td><td><s:date name="#emp.hiredate"format="yyyy/MM/dd"/></td><td><s:property value="#emp.dept.dname"/></td><td><a href="javascript:deleteMe(<s:property value="#emp.empno"/>)">删除</a><a href="javascript:updateMe(<s:property value="#emp.empno"/>)">修改</a></td></tr></s:iterator></s:if></table>add.jsp<td><label>奖金:</label></td><td><input type="text"name="m"></td></tr><tr><td><s:select name="emp.dept.deptno"label="所属部门"list="depts"listKey="deptno"listValue="dname"headerKey="0"headerValue= "请选择部门"></s:select></td></tr><tr><td colspa97插件<tr><td><label>入职日期:</label></td><td><input type="text"name="emp.hiredate"onClick="WdatePicker()"class ="Wdate"value="<s:date name='emp.hiredate'format='yyyy-MM-dd'/>"></td> </tr>。
浅谈基于过滤器与拦截器的用户访问控制
技 术 探 讨 ・ ｅｈ ｏ ｏ ｙ ａ ｄ Ｓ ｕ ｙ Ｔ ｃｎ ｌｇ ｎ ｔ ｄ
浅谈基于过滤器与拦截器的用户访问控制
郑 志 娴
（ 建 船 政 交通 职 业 学 院 福 建福 州 ３ ０ ０ ） 福 ５０ ７
【摘要 】 本文主要针对基于 Ｊ Ｅ ２ Ｅ过滤器技术与拦截器结合实现 用户的访 问控制进行讨论。文 中介绍了 Ｓ ｒｌ 过滤器技术 和 ｅｖｅ ｔ
方法。
（）ｉ １ｉ ｔ 法 ， 在 过滤 器 执 行 ｓｖｃ 前 被 调 用 ， ｎ ０方 它 ｅｉ ｒ ｅ 以设 置
过 滤器 的 配置 对象 。
大部 分时候 ，拦 截器 方法 都是通 过 代理 的方 式来 调 用的 。 Ｓ ｕｓ ｔ ｔ ２的 拦 截 器 实 现 相 对 简 单 ， 当 请 求 到 达 Ｓ ｕｓ ｒ ｔ ｔ ２的 ｒ ＳｒｌＤｓａ ｈｒ ，ｔ ｔ２会查 找配 置 文件 ， 根据 其 配 置实 ｅ ｅ ｉ ｔ ｅ 时 Ｓｒ ｓ ｖｔ ｐｃ ｕ 并 例化 相对 的拦 截 器 对象 ， 后 串 成一 个 列表 （ｓ ， 然 １ｔ 最后 一 个一 ｉ） 个地 调用 列表 中 的拦 截器 。
【 ｂ ｒ ｔ Ｔｉｐｐｒ ａ ｌｄ ｃｓｅ ｅ ｓｒｃｅｓ ｏｔｌａｅ Ｅ ｔ ｃｎｌ ｙ ｎ ｔｃｐ ｒ ｈ ａ ｒ ｔｄｃｓｈ ｅ ｌ ｉｒ Ａ ｓ ｃ 】 ｈ ｅ ｍ ｉｙ ｉｕｓｓｈ ｅａｃｓ ｎｏｂｓｄ ｎ ２ Ｅｆ ｒ ｈｏ ｇ ｄｎ ｒ ｔ． ｉｐｐ ｒ ｕｅ ｅ ｒｅＦｔ ｔ ａ ｓ ａ ｎ ｓ ｔ ｕ ｃ ｒ ｏＪ ｉ ｔ ｌ ｅ ｏ ａ ｉｅ ｅ ｏ Ｔ ｓ ｅ ｉ ｏ ｅ ｎ ｔ Ｓ ｖｔｌ ｅ
javaweb中监听器、过滤器、拦截器以及AOP的先后顺序和理解
javaweb中监听器、过滤器、拦截器以及AOP的先后顺序和理解java web三⼤器：过滤器、拦截器、监听器（spring框架）spring、springMVC与springBoot的关系详见：⼀、启动顺序监听器---》过滤器---》拦截器案例理解：接到上级命令，要求对电话进去监听，过滤出恐怖分⼦，然后，拦截他们的恐怖袭击⾏动。
配置位置：监听器、过滤器⼀般配置在web.xml中，拦截器⼀般配置在springmvc.xml配置⽂件中⼆、概念监听器：Servlet的监听器Listener，它是实现了javax.servlet.ServletContextListener接⼝的服务器端程序，它也是随web应⽤的启动⽽启动，只初始化⼀次，随web应⽤的停⽌⽽销毁。
主要作⽤是：做⼀些初始化的内容添加⼯作、设置⼀些基本的内容、⽐如⼀些参数或者是⼀些固定的对象等等Filter过滤器：过滤器拦截web访问url地址。
严格意义上讲，filter只是适⽤于web中，依赖于Servlet容器，利⽤Java的回调机制进⾏实现。
Filter过滤器：和框架⽆关，可以控制最初的http请求，但是更细⼀点的类和⽅法控制不了。
过滤器可以拦截到⽅法的请求和响应(ServletRequest request, ServletResponse response)，并对请求响应做出像响应的过滤操作，⽐如设置字符编码，鉴权操作等⽐如：（不是login.do的地址请求，如果⽤户没有登陆都过滤掉）,或者在传⼊servlet或者struts的action前统⼀设置字符集，或者去除掉⼀些⾮法字符。
主要为了减轻服务器负载，减少压⼒。
Interceptor拦截器：拦截器拦截以 .action结尾的url，拦截Action的访问。
Interfactor是基于Java的反射机制（APO思想）进⾏实现，不依赖Servlet容器。
拦截器可以在⽅法执⾏之前(preHandle)和⽅法执⾏之后(afterCompletion)进⾏操作，回调操作(postHandle)，可以获取执⾏的⽅法的名称，请求(HttpServletRequest)Interceptor：可以控制请求的控制器和⽅法，但控制不了请求⽅法⾥的参数(只能获取参数的名称，不能获取到参数的值)（⽤于处理页⾯提交的请求响应并进⾏处理，例如做国际化，做主题更换，过滤等）。
SSH题库
1. SSH中，依次处理的哪一层的实现？DA．Struts–业务逻辑层；Hibernate-表现层；Spring-持久层B．Struts-表现层；Hibernate-业务逻辑层；Spring-持久层C．Struts-持久层；Hibernate-表现层；Spring-业务逻辑层D．Struts-表现层；Hibernate-持久层；Spring-业务逻辑层2. 在Struts实现的MVC框架中，（A）类是包含了excute方法的控制器类，负责调用模型的方法，控制应用程序的流程。
A. ActionB. EJBC. ActionServletD. JSP3. 在基于Struts框架的Web应用中，下面关于Action类的说法正确的是（C）。
A. Action类属于模型组件B. Action类主要用来完成实际的业务逻辑C. Action类负责调用模型的方法，更新模型的状态，并帮助控制应用程序的流程D. 在Web应用启动时会自动加载所有的Action实例4. 下面关于数据持久化概念的描述，错误的是（D）。
A.保存在内存中数据的状态是瞬时状态B.持久状态的数据在关机后数据依然存在C.数据可以由持久状态转换为瞬时状态D.将数据转换为持久状态的机制称为数据持久化5. 下面关于Hibernate的说法，错误的是（C）。
A.Hibernate是一个“对象-关系映射”的实现B.Hibernate是一种数据持久化技术C.Hibernate是JDBC的替代技术D.使用Hibernate可以简化持久化层的编码6. 在使用了Hibernate的系统中，要想在删除某个客户数据的同时删除该客户对应的所有订单数据，下面方法可行的是（B）。
A.配置客户和订单关联的cascade属性为save-updateB.配置客户和订单关联的cascade属性为allC.设置多对一关联的inverse属性为trueD.设置多对一关联的inverse属性为false7. 执行下面的hql查询，关于返回值的说法，正确的是（B）。
Java三大器之拦截器（Interceptor）的实现原理及代码示例
Java三⼤器之拦截器（Interceptor）的实现原理及代码⽰例1，拦截器的概念java⾥的拦截器是动态拦截Action调⽤的对象，它提供了⼀种机制可以使开发者在⼀个Action执⾏的前后执⾏⼀段代码，也可以在⼀个Action执⾏前阻⽌其执⾏，同时也提供了⼀种可以提取Action中可重⽤部分代码的⽅式。
在AOP中，拦截器⽤于在某个⽅法或者字段被访问之前，进⾏拦截然后再之前或者之后加⼊某些操作。
⽬前，我们需要掌握的主要是Spring的拦截器，Struts2的拦截器不⽤深究，知道即可。
2，拦截器的原理⼤部分时候，拦截器⽅法都是通过代理的⽅式来调⽤的。
Struts2的拦截器实现相对简单。
当请求到达Struts2的ServletDispatcher时，Struts2会查找配置⽂件，并根据配置实例化相对的拦截器对象，然后串成⼀个列表（List），最后⼀个⼀个的调⽤列表中的拦截器。
Struts2的拦截器是可插拔的，拦截器是AOP的⼀个实现。
Struts2拦截器栈就是将拦截器按⼀定的顺序连接成⼀条链。
在访问被拦截的⽅法或者字段时，Struts2拦截器链中的拦截器就会按照之前定义的顺序进⾏调⽤。
3，⾃定义拦截器的步骤第⼀步：⾃定义⼀个实现了Interceptor接⼝的类，或者继承抽象类AbstractInterceptor。
第⼆步：在配置⽂件中注册定义的拦截器。
第三步：在需要使⽤Action中引⽤上述定义的拦截器，为了⽅便也可以将拦截器定义为默认的拦截器，这样在不加特殊说明的情况下，所有的Action都被这个拦截器拦截。
4，过滤器与拦截器的区别过滤器可以简单的理解为“取你所想取”，过滤器关注的是web请求；拦截器可以简单的理解为“拒你所想拒”，拦截器关注的是⽅法调⽤，⽐如拦截敏感词汇。
4.1，拦截器是基于java反射机制来实现的，⽽过滤器是基于函数回调来实现的。
（有⼈说，拦截器是基于动态代理来实现的）4.2，拦截器不依赖servlet容器，过滤器依赖于servlet容器。
详解SSH客户端配置文件
详解SSH客户端配置文件：ssh_config一、了解R S A二、什么是S S H三、S S H协议的内容四、S S H协议的安全验证五、S S H的应用六、开始配置S S H服务器1、首先确认系统已经安装了以下两个包[r o o t@l o c a l h o s t~]#r p m-q a|g r e p"z l i b-[0-9]"（z l i b包至少为 1.1.4版本）[r o o t@l o c a l h o s t~]#r p m-q a|g r e p"o p e n s s l-[0-9]"（o p e n s s l包至少为0.9.6版本）2、下载并安装o p e n s s h安装包1）下载O p e n S S H（1）官方网：w w w.o p e n s s h.o r g（2）下载当前最新版：O p e n S S H 5.3/5.3p1[r o o t@l o c a l h o s t~]#w g e tf t p://m i r r o r.m c s.a n l.g o v/p u b/o p e n s s h/p o r t a b l e/o p e n s s h-5.3p1.t a r.g z2）安装O p e n S S H（具体看O p e n S S H.t a r.g z包中的I N S T A L L文件）[r o o t@l o c a l h o s t~]#t a r-z x v f o p e n s s h-5.3p1.t a r.g z;c d o p e n s s h-5.3p1[r o o t@l o c a l h o s t o p e n s s h-5.3p1]#t o u c h r u n.s h;c h m o d u+x r u n.s h然后在r u n.s h文件中输入以下几行内容：[r o o t@l o c a l h o s t o p e n s s h-5.3p1]# ./r u n.s h&&m a k e&&m a k e i n s t a l l[r o o t@l o c a l h o s t o p e n s s h-5.3p1]#c p c o n t r i b/r e d h a t/s s h d.p a m/e t c/p a m.d/s s h d注意：一定不要忘记拷贝s s h d.p a m到/e t c/p a m.d目录下,并改名为s s h d,要不然用户就不能通过S S H服务器的”基于口令的安全验证”方式,从而不能登录S S H服务器[r o o t@l o c a l h o s t~]#e c h o"/u s r/l o c a l/o p e n s s h/s b i n/s s h d&">>/e t c/r c.l o c a l注意：安装完以后，把s s h d服务启动加入到r c.l o c a l脚本中，从而实现系统时，自动启动该服务[r o o t@l o c a l h o s t o p e n s s h-5.3p1]#c p/u s r/l o c a l/o p e n s s h/s h a r e/m a n/m a n1/*/u s r/l o c a l/s h a r e/m a n/m a n1/[r o o t@l o c a l h o s t o p e n s s h-5.3p1]#c p/u s r/l o c a l/o p e n s s h/s h a r e/m a n/m a n5/*/u s r/l o c a l/s h a r e/m a n/m a n5/[r o o t@l o c a l h o s t o p e n s s h-5.3p1]#c p/u s r/l o c a l/o p e n s s h/s h a r e/m a n/m a n8/*/u s r/l o c a l/s h a r e/m a n/m a n8/注意：把帮助文件拷贝到/u s r/l o c a l/s h a r e/m a n/下面，已便用m a n命令查看帮助[r o o t@M y l i n u x~]#u s e r a d d r u a n x i;p a s s w d r u a n x i[r o o t@M y l i n u x~]#u s e r a d d c r s k y;p a s s w d c r s k y[r o o t@M y l i n u x~]#g r o u p a d d S S H a d m i n[r o o t@M y l i n u x~]#v i/e t c/g r o u p把用户r u a n x i加入到组S S H a d m i n中，修改/e t c/g r o u p中的内容：S S H a d m i n:x:503:r u a n x i注意：这里把用户加入S S H a d m i n组中的目的是：让r u a n x i能够登录S S H服务器，而用户c r s k y没有加入到S S H a d m i n组中，也就无法登录S S H服务器了，因为一般系统管理员的人数不会很多，所以我们只让系统管理员有权登录S S H服务器，其他人员禁止登录，这样能让服务器更安全（具体还得配置s s h d_c o n f i g文件）3）修改配置文件（1）安装完o p e n s s h后，会生成以下几个配置文件（注意：这些生成的配置文件具体要放在哪个位置？这是由--s y s c o n f i g d i r参数指定的）m o d u l i#s s h服务器的D i f f i e-H e l l m a n密钥文件s s h_c o n f i g#s s h客户端配置文件s s h d_c o n f i g#s s h服务器配置文件s s h_h o s t_d s a_k e y#s s h服务器d s a算法私钥s s h_h o s t_d s a_k e y.p u b#s s h服务器d s a算法公钥s s h_h o s t_r s a_k e y#s s h服务器r s a算法私钥s s h_h o s t_r s a_k e y.p u b#s s h服务器r s a算法公钥（2）编辑s s h服务器配置文件（s s h d_c o n f i g）[r o o t@l o c a l h o s t~]#v i/u s r/l o c a l/o p e n s s h/s s h_c o n f i g（3）编辑客户端登录环境的配置文件s s h_c o n f i g，通过修改它来改变客户端程序的运行方式[r o o t@M y l i n u x~]#v i/u s r/l o c a l/o p e n s s h/s s h_c o n f i g（4）配置S S H服务器的论证方式第一种：基于口令的论证方式：只需要对上面的配置文件：s s h d_c o n f i g与s s h_c o n f i g做些修改，修改如下：在上面的服务器配置文件s s h d_c o n f i g中，只需去掉下列行的“#”号#P a s s w o r d A u t h e n t i c a t i o n y e s==>P a s s w o r d A u t h e n t i c a t i o n y e s#C h a l l e n g e R e s p o n s e A u t h e n t i c a t i o n y e s==>C h a l l e n g e R e s p o n s e A u t h e n t i c a t i o n y e s在上面的客户端配置文件s s h_c o n f i g中，只需去掉下列行的“#”号#P a s s w o r d A u t h e n t i c a t i o n y e s==>P a s s w o r d A u t h e n t i c a t i o n y e s如果已启动s s h d服务，那么重新启动一下s s h d（k i l l a l l-H U P s s h d），如果还没有启动s s h d服务，现在就用指令："/u s r/l o c a l/o p e n s s h/s b i n/s s h d &"启动s s h d服务，然后让用户：r o o t与c r s k y分别重新登录，此时会产生如下结果：分析原因：在服务器配置文件s s h d_c o n f i g中设置不允许r o o t用户登录S S H服务器，另外用户c r s k y不属于S S H a d m i n组的成员，所以也无法登录S S H服务器第二种：基于密钥的论证方式：只需要对上面的配置文件：s s h d_c o n f i g与s s h_c o n f i g做些修改，修改如下：在上面的服务器配置文件s s h d_c o n f i g中，修改如下几行#H o s t K e y/u s r/l o c a l/o p e n s s h/s s h_h o s t_r s a_k e y==>H o s t K e y/u s r/l o c a l/o p e n s s h/s s h_h o s t_r s a_k e y#H o s t K e y/u s r/l o c a l/o p e n s s h/s s h_h o s t_d s a_k e y==>H o s t K e y /u s r/l o c a l/o p e n s s h/s s h_h o s t_d s a_k e y#A u t h o r i z e d K e y s F i l e.s s h/a u t h o r i z e d_k e y s==>A u t h o r i z e d K e y s F i l e.s s h/ a u t h o r i z e d_k e y s#P a s s w o r d A u t h e n t i c a t i o n y e s==>P a s s w o r d A u t h e n t i c a t i o n n o#C h a l l e n g e R e s p o n s e A u t h e n t i c a t i o n y e s==>C h a l l e n g e R e s p o n s e A u t h e n t i c a t i o n n o在上面的客户端配置文件s s h_c o n f i g中，修改如下几行#I d e n t i t y F i l e~/.s s h/i d_r s a==>I d e n t i t y F i l e~/.s s h/i d_r s a#I d e n t i t y F i l e~/.s s h/i d_d s a==>I d e n t i t y F i l e~/.s s h/i d_d s a#P a s s w o r d A u t h e n t i c a t i o n y e s==>P a s s w o r d A u t h e n t i c a t i o n n o七、O p e n S S H用户工具1、s s h（登录远程S S H服务器）1）S S H服务器基于密钥的认证方式[r u a n x i@M y l i n u x~]$s s h-l r u a n x i-i~/.s s h/i d_r s a-p2222-2192.168.1.1002）S S H服务器基于密码的认证方式[r u a n x i@M y l i n u x~]$s s h-l r u a n x i-p2222192.168.1.100;3）使用S S H登录来执行远程的一些命令[r u a n x i@M y l i n u x~]$s s h-l r u a n x i-p2222-2-q-i~/.s s h/i d_r s a192.168.1.100'l s-l/t m p;l s-l /e t c/g r u b.c o n f'（即：使用用户账号r u a n x i安静登录，并使用密钥方式来验证，登录后执行命令：l s -l/t m p，把结果返回到本地终端并退回到本地）参数解析-p：不使用默认端口，使用2222端口-2：选用S S H v2-l：登录用户名-i：指定登录的用户的私钥存放位置-q：安静模式登录2、s s h-k e y g e n工具例如：为ruanxi用户修改pass-phrase。
SSH配置
SSH 配置SSH 配置作者：admin 文章来源：本站原创 点击数： 15 更新时间：2009-12-28 18:22:24配置客户端的软件OpenSSH 有三种配置方式：命令行参数、用户配置文件和系统级的配置文件（"/etc/ssh/ssh_config"）。
命令行参数优先于配置文件，用户配置文件优先于系统配置文件。
所有的命令行的参数都能在配置文件中设置。
因为在安装的时候没有默认的用户配置文件，所以要把 "/etc/ssh/ssh_config"拷贝并重新命名为"~/.ssh/config"。
标准的配置文件大概是这样的：[lots of explanations and possible options listed]# Be paranoid by defaultHost *ForwardAgent noForwardX11 noFallBackToRsh no还有很多选项的设置可以用"man ssh"查看"CONFIGURATION FILES"这一章。
配置文件是按顺序读取的。
先设置的选项先生效。
假定你在 上有一个名为"bilbo"的帐号。
而且你要把"ssh-agent"和"ssh-add"结合起来使用并且使用数 据压缩来加快传输速度。
因为主机名太长了，你懒得输入这么长的名字，用"fbc"作为""的简称。
你的配置文件可以是这样 的：Host *fbc HostName User bilboForwardAgent yesCompression yes# Be paranoid by defaultHost *ForwardAgent noForwardX11 noFallBackToRsh no你输入"ssh fbc"之后，SSH 会自动地从配置文件中找到主机的全名，用你的用户名登录并且用"ssh-agent"管理的密匙进行安全验证。
SSH异常和日志处理方案
SSH异常和日志处理方案kaqike 2011-4-251异常和日志的作用1.1.异常的作用Java异常机制是为了对程序中可能出现的已知错误进行捕获，并进行相应处理。
从是否反馈给用户来看，存在两类异常：系统异常：这类异常由系统本身的低级异常引起，例如数据库连接失败、内存溢出、空指针异常等等，这类异常不需要出现在前台，因为用户看不懂也没有必要看到这些异常信息。
这类异常需要在日志中进行完整记录以供日后开发人员进行查看分析。
应用异常：即自定义异常，这类异常需要通过前台反馈给用户，友好提示用户当前操作异常。
应用异常通过系统异常转换而来，例如新建用户时，发生“主键冲突异常”，则需要在UserinfoDao中将“主键冲突异常”捕获，并转换为应用异常，异常提示信息设为“该用户名XXX已存在，请使用其它用户名”，并将该异常信息反馈给前台。
只要系统异常影响到的用户的当前操作，就必须给用户提示信息，比如“系统后台发生错误，请稍后再试”等。
应用异常应按照提示方式的异常进行分类，对应不同的提示页面。
1.2.日志的作用系统运行日志：记录系统的运行情况，跟踪代码运行时轨迹；异常和错误日志：记录异常堆栈信息，以供开发人员查看分析；业务日志：记录业务信息和用户操作，例如用户登录、删除数据、更新数据等。
2.异常的处理原则1、避免过大的try块，不要把不会出现异常的代码放到try块里面，尽量保持一个try块对应一个或多个异常。
2、细化异常的类型，不要不管什么类型的异常都写成Excetpion。
c atch语句表示我们预期会出现某种异常，而且希望能够处理该异常。
异常类的作用就是告诉Java编译器我们想要处理的是哪一种异常，然后针对具体的异常类进行不同的处理。
例如在DAO层中我们应该只捕获SQLException或DataAccessException(Spring自定义的数据访问异常类)这些数据库异常类，其他的异常NullPointException、NumberFormatException等应通过检测代码增加其健壮性来解决，而不应该通过try..catch(Exception e)…语句捕获所有的异常。
java_过滤器、监听器_拦截器_原理个人总结
过滤器创建一个Filter 只需两个步骤:(1)创建Filter 处理类:(2)在web.xml 文件中配置Filter 。
创建Filter 必须实现javax.servlet.Filter 接口，在该接口中定义了三个方法。
• void init(FilterConfig config): 用于完成Filter 的初始化。
• void destroy(): 用于Filter 销毁前，完成某些资源的回收。
• void doFilter(ServletRequest request, ServletResponse response,FilterChain chain): 实现过滤功能，该方法就是对每个请求及响应增加的额外处理。
过滤器Filter也具有生命周期：init()->doFilter()->destroy()，由部署文件中的filter元素驱动。
在servlet2.4中，过滤器同样可以用于请求分派器，但须在web.xml中声明，<dispatcher>INCLUDE或FORWARD或REQUEST或ERROR</dispatcher>该元素位于filter-mapping中。
一、理解Struts2拦截器1. Struts2拦截器是在访问某个Action或Action的某个方法，字段之前或之后实施拦截，并且Struts2拦截器是可插拔的，拦截器是ＡＯＰ的一种实现．解析：--------------------------------------------------------------------------------------------拦截器和AOP的关系拦截器与AOP （Aspect Orient Program ，面向切面编程）是密切相关的，AOP 从程序运行角度来考虑程序的流程，取得业务处理过程的切面，在特定切面通过系统自动插入特定方法。
SSH复习题
SSH复习题选择题1、下面哪一个不是框架（D）。
A.SpringB.StrutC.HibernateD.JSP2、下面是框架的是（D）。
A.定义实体类B.数据的增删改查操作C.业务逻辑的描述D.页面展示和控制转发4、在三层结构中，Hibernate承担的任务是（A）。
A．数据的持久化操作B.实体类的定义C.业务逻辑的描述D.页面的显示与控制转发5、下面信息不在Strut2配置文件中配置的是（B）。
A.FormBean配置信息B.Spring声明式事务C.Action转发路径D.Strut2引用的资源文件6、在trut实现的框架中,（B）类包含了e某cute方法的控制器类，负责调用模型的方法，控制应用程序的流程。
A．Aja某B．ActionC．FormD．Method7、下面关于Hibernate的说法，错误的是（C）。
A.Hibernate是一个“对象-关系映射”的实现B.Hibernate是一种数据持久化技术C.Hibernate是JDBC的替代技术D.使用Hibernate可以简化持久化层的编码8、下列说法中错误的是（C）。
A．使用通配符可以优化action的配置B．约定优于配置。
约定的如果好，可以使action配置非常的简洁C．如果Action中存在多个方法时，只能使用method属性指定调用方法D．在trut2中超级链接通常都采用绝对路径，而不使用相对路径，这样便于链接的实现9、下列说法中错误的是（D）。
A．从值栈中取值用value=“参数名”，参数名是action中的参数B．从actionconte某t中取值用#parameter.参数名，参数名是trut中的参数C．在客户端跳转时一次requet只有一个valueStackD．在客户端跳转时一次requet可以有多个valueStack10、和SQL相比，HQL有哪些优点（C）。
A．HQL能够简单的操作表B.HQL是简单的ql语言组成C.HQL是面向对象的检索语言D.HQL对应的是表和表的字段11、一个某ML文件能被浏览器解析的最小要求是(A)。
ssh三大框架整合
ssh三⼤框架整合Hibernate框架 1 hibernate核⼼配置⽂件 （0）orm思想 - 对象关系映射 （1）数据库信息 （2）hibernate信息 （3）映射配置 （4）hibernate核⼼配置⽂件 - 如果单纯使⽤hibernate框架，核⼼配置⽂件名称 hibernate.cfg.xml和位置 src下⾯固定的 - hibernate和spring整合时候，hibernate核⼼配置⽂件名称和位置没有固定要求的 2 hibernate映射配置⽂件 （1）实体类和数据库表映射关系—使⽤orm思想 3 hibernate操作的步骤 （1）在spring框架对hibernate框架进⾏封装，使⽤hibernateTemplateStruts2框架 1 Action操作 （1）action创建三种⽅式 - 继承类 ActionSupport （2）配置action访问路径 - 创建struts.xml配置⽂件，这个⽂件名称和位置固定 src下⾯的 （3）配置访问action的多个⽅法 - 使⽤通配符⽅式配置 （4）在action获取表单提交数据 - 获取request对象 ** 使⽤ServletActionContext类获取 - 属性封装 - 模型驱动（重点） - 表达式封装 （5）在action操作域对象 - 使⽤ServletActionContext获取域对象 （6）配置struts2的过滤器 2 值栈 （1）向值栈放数据 - set⽅法 - push⽅法 - 定义变量，⽣成get⽅法 （2）从值栈获取数据 - 在jsp中使⽤struts2标签+ognl获取 - <s:property> - <s:iterator> 3 拦截器 （1）aop和责任链模式 （2）⾃定义拦截器 - 继承MethodFilterInterceptor - 重写类⾥⾯的⽅法 - 配置拦截器和action关联Spring框架 1 spring核⼼配置⽂件 （1）名称和位置没有固定要求 （2）在spring核⼼配置⽂件中引⼊schema约束 2 创建对象 （1）xml配置⽅式：<bean id=”” class=”” scope=””/> （2）注解⽅式：四个注解 3 注⼊属性(对象类型属性) （1）xml配置⽅式： （2）注解⽅式：两个注解 - autowired - resource 3 使⽤ServletContext对象和监听器实现 （1）在服务器启动时候，加载spring配置⽂件，创建对象 （2）配置spring的监听器 （3）指定spring配置⽂件位置 4 jdbcTemplate 5 spring事务配置 （1）xml⽅式 （2）注解⽅式SSH框架整合思想 1 三⼤框架应⽤在javaee三层结构 2 struts2框架和spring整合 （1）struts2的action在spring配置 3 spring框架和hibernate框架整合 （1）hibernate的sessionFactory交给spring配置 （2）把hibernate数据库配置交给spring配置整合struts2和spring框架 1 把struts2的action交给spring管理 2 实现过程 第⼀步导⼊struts2的jar包 （1）导⼊⽤于整合的jar包 （log4j.properties为log4j的⽇志输出格式，放⼊src下⾯） （2）Spring为了整合Struts还需要额外再导⼊⼀个jar包：（该包在struts的lib⽬录下） （3）导⼊Struts2的jar包（struts2版本为2.3.24）： （4）创建Actionpublic class UserAction extends ActionSupport {public String execute() throws Exception {System.out.println("Success....");return NONE;}} （5）创建Strut2的核⼼配置⽂件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN""/dtds/struts-2.3.dtd"><struts><package name="demo" extends="struts-default" namespace="/"><action name="userAction" class="erAction"></action></package></struts> （6）在web.xml中配置struts2的过滤器<filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping> （7）导⼊Spring整合Web项⽬的jar包，也就是监控项⽬启动的监听器所在的jar包 （8）创建Spring的核⼼配置⽂件并在其中引⼊约束<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/tx/schema/tx/spring-tx.xsd"></beans> （9）把action交给Spring进⾏配置1 <!-- 配置action的对象 -->2 <!-- 注意action是多实例的，因此我们这⾥把scope配置为prototype的 -->3 <bean id="userAction" class="erAction" scope="prototype"></bean> ①在spring配置action对象，在struts.xml中也配置action对象 ②解决： 只需要在spring⾥⾯配置action对象，不要在struts.xml中配置<struts><package name="demo1" extends="struts-default" namespace="/"><!-- class属性⾥⾯不写action全路径了，因为写，action对象创建两次写spring配置的action的bean的id值--><action name="userAction" class="userAction"></action></package></struts> 可以这样写的原因是我们导⼊了⼀个Spring整合Struts2的jar包：struts2-spring-plugin-2.3.24.jar （10）web.xml中Spring监听器的配置<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:bean.xml</param-value></context-param> （11）测试准备 ①所需的为Struts2的核⼼配置⽂件：struts.xml ②Spring的配置⽂件：bean.xml ③项⽬的配置⽂件：web.xml ④Struts2的UserAction类 ⑤在UserAction中对UserService的调⽤ ⑥UserService中对UserDao的调⽤ ⑦UserDao类的编写struts.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN""/dtds/struts-2.3.dtd"><struts><package name="demo1" extends="struts-default" namespace="/"><!-- class属性⾥⾯不写action全路径了，因为写，action对象创建两次写spring配置的action的bean的id值--><action name="userAction" class="userAction"></action></package></struts>bean.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/tx/schema/tx/spring-tx.xsd"><bean id="userAction" class="erAction"><property name="userService" ref="userService"></property></bean><bean id="userService" class="erService"><property name="userDao" ref="userDaoImp"></property></bean><bean id="userDaoImp" class="erDaoImp"></bean></beans>web.xml<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance" xmlns="/xml/ns/javaee" xsi:schemaLocation="/xml/ns/javaee /xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" <display-name>spring-day4-ssh</display-name><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:bean.xml</param-value></context-param><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping><welcome-file-list><welcome-file>index.html</welcome-file><welcome-file>index.htm</welcome-file><welcome-file>index.jsp</welcome-file><welcome-file>default.html</welcome-file><welcome-file>default.htm</welcome-file><welcome-file>default.jsp</welcome-file></welcome-file-list></web-app>UserAction.javaimport com.opensymphony.xwork2.ActionSupport;import erService;public class UserAction extends ActionSupport {private UserService userService;public void setUserService(UserService userService) {erService = userService;}public String execute() throws Exception {userService.add();return NONE;}}UserService.javapublic class UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {erDao = userDao;}public void add() {userDao.add();}}UserDao.java 其实现类public class UserDaoImp implements UserDao {public void add() {System.out.println("UserDaoImp....");}} （12）测试结果： 可以在后台观察到如下测试结果：image ⾄此，Spring和Struts2的整合已经完毕，然后是Spring对Hibernate的整合了。
SSH各框架工作原理
SSH各框架的工作原理struts1的工作原理：1.初始化：struts框架的总控制器ActionServlet是一个Servlet，它在web.xml中配置成自动启动的Servlet，在启动时总控制器会读取配置文件(struts-config.xml)的配置信息，为struts中不同的模块初始化相应的对象。
(面向对象思想)2.发送HTTP请求：用户提交表单或通过URL向WEB服务器提交请求，请求的数据用HTTP协议传给web服务器。
3.form填充：struts的总控制器ActionServlet在用户提交请求时将数据放到对应的form对象中的成员变量中。
4.将请求派发到具体的Action处理：控制器根据配置信息对象ActionConfig将请求派发到具体的Action，对应的formBean一并传给这个Action中的excute()方法。
5.处理业务：Action一般只包含一个excute()方法，它负责执行相应的业务逻辑(调用其它的业务模块)完毕后返回一个ActionForward对象。
服务器通过ActionForward对象进行转发工作。
6.返回目标响应对象：Action将业务处理的不同结果返回一个目标响应对象给总控制器。
7.转换HTTP请求到目标响应对象：总控制器根据Action处理业务返回的目标响应对象，找到对应的资源对象，一般情况下为jsp页面。
8.响应用户：目标响应对象将结果传递给资源对象，将结果展现给用户。
struts-config.xml模型（ActionForm）业务功能类（JavaBean）1、初始化3、填充Form2、HTTP请求JSP页面Struts框架总控制器（ActionServlet）7、转换HTTP请求到目标响应对象8、HTTP响应4、将请求派发到具体的Action处理6、返回目标响应对象5、调用后台业务功能处理业务业务功能控制器（Action）Struts2工作原理：1初始化：客户端初始化一个指向Servlet容器（例如Tomcat）的请求2这个请求经过一系列的过滤器（Filter）(这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）3接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action4如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy5.ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类6.ActionProxy创建一个Action Invocation的实例。
详解ssh框架原理及流程
详解ssh框架原理及流程什么是SSHSSH是 struts+spring+hibernate的⼀个集成框架，是⽬前较流⾏的⼀种web应⽤程序开源框架。
SSH不是⼀个框架，⽽是把多个框架（Struts、Spring以及Hibernate）紧密的结合在⼀起，⽤于构建灵活、易于扩展的多层Web应⽤程序。
SSH框架的系统从职责上分为四层：表⽰层、业务逻辑层、数据持久层和域模块层(实体层)。
SSH（Struts2+Spring+Hibernate）框架的项⽬，该架构主要分为三个层次：（1）Struts2：负责web层（2）Spring：业务层的管理（3）Hibernate：负责数据持久化Struts2⼯作原理：1.初始化⼀个指向servlet容器的请求。
2.请求经过web.xml中配置的过滤器过滤，FilterDispatcher（struts2控制器的核⼼）询问ActionMapper是否需要调⽤某个Action来处理这个请求。
如果ActionMapper决定需要调⽤某个Action，FilterDispatcher则把请求的处理交给ActionProxy。
3.ActionProxy通过配置⽂件Struts.xml配置⽂件找到需要调⽤的Action类。
4.ActionProxy创建⼀个ActionInvocation实例，同时ActionInvocation通过代理模式调⽤Action。
但在调⽤之前，ActionInvocation会根据配置加载Action相关的所有Interceptor（拦截器）。
5.Action执⾏完毕后，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果result。
即开发⼈员通过发送http请求，这个请求经过web.xml的过滤器过滤看看是否要调⽤某个action，如果有则在Struts.xml找到该请求的实现的⽅法，然后返回运⾏的结果。
Hibernate⼯作原理：1. 读取并解析配置⽂件2.读取并解析映射信息，创建SessionFactory3. 打开Sesssion4.创建事务Transation5. 持久化操作6.提交事务7.关闭Session8. 关闭SesstionFactory即通过spring管理的Hibernate初始化时加载了xxx.hbm.xml然后读取解析映射信息，创建了SessionFactory。
ssh工具详解
SSH为Secure Shell的缩写，由IETF的网络工作小组（Network Working Group）所制定；SSH为创建在应用层和传输层基础上的安全协议。
传统的网络服务程序，如FTP、POP和Telnet其本质上都是不安全的；因为它们在网络上用明文传送数据、用户帐号和用户口令，很容易受到中间人（man-in-the-middle）攻击方式的攻击。
就是存在另一个人或者一台机器冒充真正的服务器接收用户传给服务器的数据，然后再冒充用户把数据传给真正的服务器。
而SSH是目前较可靠，专为远程登录会话和其他网络服务提供安全性的协议。
利用SSH协议可以有效防止远程管理过程中的信息泄露问题。
通过SSH可以对所有传输的数据进行加密，也能够防止DNS欺骗和IP欺骗。
SSH之另一项优点为其传输的数据是经过压缩的，所以可以加快传输的速度。
SSH有很多功能，它既可以代替Telnet，又可以为FTP、POP、甚至为PPP提供一个安全的“通道”。
历史最初的SSH协议是由芬兰的一家公司开发的，但是因为受版权和加密算法等等的限制，现在很多人都转而使用OpenSSH。
OpenSSH是SSH的替代软件包，而且是开放源代码和免费的。
基本架构SSH协议框架中最主要的部分是三个协议：1.传输层协议（The Transport Layer Protocol）：传输层协议提供服务器认证，数据机密性，信息完整性等的支持。
2.用户认证协议（The User Authentication Protocol）：用户认证协议为服务器提供客户端的身份鉴别。
3.连接协议（The Connection Protocol）：连接协议将加密的信息隧道复用成若干个逻辑通道，提供给更高层的应用协议使用。
同时还有为许多高层的网络安全应用协议提供扩展的支持。
各种高层应用协议可以相对地独立于SSH基本体系之外，并依靠这个基本框架，通过连接协议使用SSH的安全机制。
SpringBoot使用过滤器和拦截器分别实现REST接口简易安全认证示例代码详解
SpringBoot使⽤过滤器和拦截器分别实现REST接⼝简易安全认证⽰例代码详解本⽂通过⼀个简易安全认证⽰例的开发实践，理解过滤器和拦截器的⼯作原理。
很多⽂章都将过滤器（Filter）、拦截器（Interceptor）和监听器（Listener）这三者和Spring关联起来讲解，并认为过滤器（Filter）、拦截器（Interceptor）和监听器（Listener）是Spring提供的应⽤⼴泛的组件功能。
但是严格来说，过滤器和监听器属于Servlet范畴的API，和Spring没什么关系。
因为过滤器继承⾃javax.servlet.Filter接⼝，监听器继承⾃javax.servlet.ServletContextListener接⼝，只有拦截器继承的是org.springframework.web.servlet.HandlerInterceptor接⼝。
上⾯的流程图参考⾃⽹上资料，⼀图胜千⾔。
看完本⽂以后，将对过滤器和拦截器的调⽤过程会有更深刻理解。
⼀、安全认证设计思路有时候内外⽹调⽤API，对安全性的要求不⼀样，很多情况下外⽹调⽤API的种种限制在内⽹根本没有必要，但是⽹关部署的时候，可能因为成本和复杂度等问题，内外⽹要调⽤的API会部署在⼀起。
实现REST接⼝的安全性，可以通过成熟框架如Spring Security或者 shiro 搞定。
但是因为安全框架往往实现复杂（我数了下Spring Security，洋洋洒洒⼤概有11个核⼼模块，shiro的源码代码量也⽐较惊⼈）同时可能要引⼊复杂配置（能不能让⼈痛快⼀点），不利于中⼩团队的灵活快速开发、部署及问题排查。
很多团队⾃⼰造轮⼦实现安全认证，本⽂这个简易认证⽰例参考⾃我所在的前⼚开发团队，可以认为是个基于token的安全认证服务。
⼤致设计思路如下：1、⾃定义http请求头，每次调⽤API都在请求头⾥传⼈⼀个token值2、token放在缓存（如redis）中，根据业务和API的不同设置不同策略的过期时间3、token可以设置⽩名单和⿊名单，可以限制API调⽤频率，便于开发和测试，便于紧急处理异状，甚⾄临时关闭API4、外⽹调⽤必须传⼈token，token可以和⽤户有关系，⽐如每次打开页⾯或者登录⽣成token写⼊请求头，页⾯验证cookie和token有效性等在Spring Security框架⾥有两个概念，即认证和授权，认证指可以访问系统的⽤户，⽽授权则是⽤户可以访问的资源。
SSH+过滤器(filter)
缺少 3 个包，拷入 ssh 整合使用的完整包即可。
六、自动生成 po 实体类
点击 Finish 七、自动 dao 实现类 打开 po 包下自动生成的 DAO 类 去修改包路径
CTRL+1 点 Move
CTRL+SHIFT+O 重新导包 八、自动生成对应的借口 对 ProductsDAO 类 提取接口，并进行 AOP 的 set 配置
点 Next
击
Test
Driver
OK
点
击
OKFinish
四、添加 spring 支持
Next
体现了对数据的安全性
Finish 五、添加 hibernate 支持
Next
Next
Next
配置的数据源名称
Next
Finish
Jar 包冲突，Keep Existing 继续保持，Replace 替代,Cancel 取消。 选择 keep ExistingLeabharlann 修改第三块 bean 原为：
<bean id="ProductsDAO" class="com.accp.dao.impl.ProductsDAO"> <property name="sessionFactory"> <ref bean="sessionFactory" /> </property> </bean> 改为： <bean name="/showIt" class="com.accp.struts.action.ShowItAction"> <property name="productsBiz"> <ref bean="ProductsBiz" /> </property> </bean> 注意改 id 为 name 里面填上 action 的路径 Class 为 action 的类的全名
拦截器（Interceptor）与过滤器（Filter）
拦截器（Interceptor）与过滤器（Filter）⽬录⼀、⽤户的普通Http请求执⾏顺序⼆、过滤器、拦截器添加后的执⾏顺序三、拦截器（Interceptor）的基本定义 拦截器是⾯向切⾯（AOP）编程中应⽤的⼀种统⼀处理⽅案，就是在你的Controller、Servie或者⼀个Method调⽤⼀个Method，或者在Method调⽤⼀个Method之后，统⼀的进⾏处理的⽅案，基于Java的反射机制。
拦截器，在AOP（Aspect-Oriented Programming）中可以⽤于在某个⽅法或者字段被访问之前，进⾏拦截，然后在之前或者之后加⼊某些统⼀的处理⽅法。
拦截是AOP的⼀种具象的实现⽅式。
拦截器将很多service或者Controller中共有的⾏为提炼出来，在某些⽅法执⾏的前后执⾏，提炼为通⽤的处理⽅式，让被拦截的⽅法都能享受这⼀共有的功能，让代码更加简洁，同时，当共有的功能需要发⽣调整、变动的时候，不必修改很多的类或者⽅法，只要修改这个拦截器就可以了，可复⽤性很强。
Spring MVC 中的Interceptor拦截请求是通过HandlerInterceptor来实现的。
四、拦截器（Interceptor）必须实现的三个⽅法 1）总览 2）preHandle（HttpServletRequest request， HttpServletResponse response， Object handle）⽅法 该⽅法将在请求处理之前进⾏调⽤。
SpringMVC 中的Interceptor 是链式的调⽤的，在⼀个应⽤中或者说是在⼀个请求中可以同时存在多个Interceptor 。
每个Interceptor 的调⽤会依据它的声明顺序依次执⾏，⽽且最先执⾏的都是Interceptor 中的preHandle ⽅法，所以可以在这个⽅法中进⾏⼀些前置初始化操作或者是对当前请求的⼀个预处理，也可以在这个⽅法中进⾏⼀些判断来决定请求是否要继续进⾏下去。
ssh拦截器
ssh拦截器配置一、首先是建立一个拦截器类实现拦截后的主要功能例如实现“已经登录”的验证，这个在方法体中定义。
package mon;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpSession;import org.apache.struts2.ServletActionContext;import er;import com.opensymphony.xwork2.ActionInvocation;import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;public class CheckLogin extends MethodFilterInterceptor {private static final long serialVersionUID = 1L;@Overrideprotected String doIntercept(ActionInvocation arg0) throws Exception { HttpServletRequest request = ServletActionContext.getRequest(); HttpSession session = request.getSession();User user= (User) session.getAttribute("user");if (user.getName().equals("") || user.getName() == null) {return "login";} else {return arg0.invoke();}}}二、接下来则是在struts.xml文件中添加标签信息。
Interceptor说明
Interceptor说明Interceptor的接口定义没有什么特别的地方，除了init和destory方法以外，intercept方法是实现整个拦截器机制的核心方法。
而它所依赖的参数ActionInvocation则是我们之前章节中曾经提到过的著名的Action调度者。
我在这里需要指出的是一个很重要的方法invocation.invoke()。
这是ActionInvocation中的方法，而ActionInvocation是Action调度者，所以这个方法具备以下2层含义(详细看DefaultActionInvocation源代码)：1. 如果拦截器堆栈中还有其他的Interceptor，那么invocation.invoke()将调用堆栈中下一个Interceptor的执行。
2. 如果拦截器堆栈中只有Action了，那么invocation.invoke()将调用Action 执行。
3.DefaultActionInvocation部分源代码:if (interceptors.hasNext()) {final InterceptorMapping interceptor = (InterceptorMapping) interceptors.next();UtilTimerStack.profile("interceptor: "+interceptor.getName(),new UtilTimerStack.ProfilingBlock<String>() {public String doProfiling() throws Exception {resultCode =interceptor.getInterceptor().intercept(DefaultActionInvocation.this); //递归调用拦截器return null;}});} else {resultCode = invokeActionOnly();}每个拦截器中的代码的执行顺序，在Action之前，拦截器的执行顺序与堆栈中定义的一致；而在Action和Result之后，拦截器的执行顺序与堆栈中定义的顺序相反。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
SSH中自定义监听器、拦截器、过滤器1、自定义监听器a)自定义监听器有哪些监听器的定义是在web.xml中完成，其实做过ssh项目的人并不陌生监听器，主要是因为spring提供了监听器就是<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>如果我们想自己定义一个监听器来完成我们自己的特定功能怎么办呢，struts为我们提供了自定义servlet监听器，他们主要有（1）ServletContextListenerServlet的上下文监听，它主要实现监听ServletContext的创建和删除。
该接口提供了两种方法1.contextInitialized(ServletContextEvent event); 通知正在收听的对象，应用程序已经被加载和初始化。
2.contextDestroyed(ServletCotextEvent event); 通知正在收听的对象，应用程序已经被载出，即关闭。
（2）ServletAttributeListener主要实现监听ServletContext属性的增加，删除和修改。
该接口提供了一下3个方法1.attributeAdded(ServletContextAttributeEvent event); 当有对象加入Application的范围时，通知正在收听的对象2.attributeReplaced(ServletContextAttributeEvent event); 当在application的范围有对象取代另一个对象的时，通知正在收听的对象3.attributeRemoved(ServletContextAttributeEvent event); 当有对象从application的范围移除时，通知正在收听的对象（3）HttpSessionListenerHTTP会话监听，该接口实现监听HTTP会话创建、销毁。
该接口提供了一下两种方法1.sessionCreated(HttpSessionEvent event); 通知正在收听的对象，session已经被加载及初始化2. sessionDestoryed(HttpSessionEvent event)l 通知正在收听的对象，session已经被载出（HttpSessionEvent类的主要方法是getSession(),可以使用该方法回传一个session对象）（4）HttpSessionActivationListener该接口实现监听HTTP会话active和passivate。
该接口提供了一下3个方法1.attributeAdded（HttpSessionBindingEvent event）; 当有对象加入session的范围时，通知正在收听的对象2.attributeReplaced（HttpSessionBindingEvent event）; 当在session的范围有对象取代另一个对象时，通知正在收听的对象。
3.attributeRemoved(HttpSessionBindingEvent event); 当有对象从session的范围有对象取代另一个对象时，通知正在收听的对象其中HttpSessionBindingEvent类主要有三个方法：getName()、getSession()和getValue()（5）HttpBindingListener接口实现监听HTTP会话中对象的绑定信息。
它是唯一不需要在web.xml中设定Listener的。
该接口提供了以下2个方法1.valueBound(HttpSessionBindingEvent event); 当有对象加入session的范围时会被自动调用2.valueUnBound(HttpSessionBindingEvent event); 当有对象从session的范围内移除时会被自动调用（6）HttpSessionAttributeListener该接口实现监听HTTP会话中属性的设置请求。
该接口提供了以下两个方法。
1.sessionDidActivate（HttpSessionEvent event); 通知正在收听的对象，它的session已经变为有效状态。
2.sessionWillPassivate(HttpSessionEvent event); 通知正在收听的对象，它的session已经变为无效状态（7）ServletRequestListener该接口提供了以下两个方法。
1.requestInitalized(ServletRequestEvent event) 通知正在收听的对象，ServletRequest已经被加载及初始化2.requestDestroyed(ServletRequestEvent event) 通知正在收听的对象，ServletRequest已经被载出，即关闭（8）ServletRequestAttributeListener该接口提供了一下三种方法1.attributeAdded（ServletRequestAttributeEvent event）；当有对象加入request的范围时，通知正在收听的对象2.attributeReplaced(ServletRequestAttributeEvent event); 当在request的范围内有对象取代两一个对象时，通知正在收听的对象3.attributeRemoved（ServletRequestAttributeEvent event）; 当有对象从request的范围移除时，通知正在收听的对象b)怎么去自定义监听器1）在web.xml中加入这一样一段话<!-- 监听器的使用，监听session对象 --><listener><listener-class>com.wlm.iagtc.listener.SessionListener</listener- class></listener>把自己定义的监听器类的全路径写进去SessionListener.java类package com.wlm.iagtc.listener;import java.util.Enumeration;import javax.servlet.http.HttpSession;import javax.servlet.http.HttpSessionEvent;import javax.servlet.http.HttpSessionListener;public class SessionListener implements HttpSessionListener{public void sessionCreated(HttpSessionEvent se) {System.out.println("session监听器启动！！！");HttpSession session = se.getSession();Enumeration login = session.getAttributeNames();if(login.hasMoreElements()){System.out.println("监听到了session对象的创建"+login.nextElement());}System.out.println(session.getId()+"----id");}public void sessionDestroyed(HttpSessionEvent se) {System.out.println("session监听器销毁！！！");HttpSession session = se.getSession();Enumeration login = session.getAttributeNames();if(login.hasMoreElements()){System.out.println("监听到session对象的消失！"+login.nextElement());}}}就这样就可以监听session对象的创建和销毁了注：session的创建：对象在你打开浏览器访问网站的一瞬间就框架就已经创建了Session的销毁：session的销毁有三种方式1、关闭浏览器2、利用代码invalidate()方法销毁session对象3、设置session过期时间，销毁session<!-- 配置session时长，也就是说如果用户长时间没有访问服务器，就杀死session --><session-config><session-timeout>5</session-timeout></session-config>你可以根据不同的接口，来监听不同的事件。
2、自定义过滤器a)过滤器的创建过滤器struts2自己就定义的有，是默认的过滤器在web.xml中<!-- 定义默认过滤器 --><filter><!-- 过滤器的名字 --><filter-name>struts2</filter-name><!-- 过滤器的类文件 --><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class></filter><!-- 启动过滤器 --><filter-mapping><!-- 要引用的过滤器 --><filter-name>struts2</filter-name><!-- 过滤器的url串，这里是过滤全部 --><url-pattern>/*</url-pattern></filter-mapping>过滤器是Servlet2.3以上新增加的一个功能，其技术也是非常强大的。
通过Filter技术可以对WEB服务器的文件进行拦截，从而实现一些特殊的功能。