sssh文章
来源：互联网 发布：自学编程入门先学什么 编辑：程序博客网 时间：2024/05/12 09:02
SSH中 struts hibernate spring 各起到的作用
简单的说：
struts 控制用的
hibernate 操作数据库的
spring 用解耦的
详细的说：
STRUTS 在 SSH 框架中起控制的作用 , 其核心是 Controller, 即 ActionServlet, 而 ActionServlet 的核心就是 Struts-confi g.xml. 主要控制逻辑关系的处理 .
hibernate 是数据持久化层 , 是一种新的对象、关系的映射工具 , 提供了从 Java 类到数据表的映射，也提供了数据查询和恢复等机制 , 大大减少数据访问的复杂度。把对数据库的直接操作 , 转换为对持久对象的操作 . SPRING 是一个轻量级的控制反转 (IoC) 和面向切面 (AOP) 的容器框架 , 面向接口的编程 , 由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。这也就是所谓 “ 控制反转 ” 的概念所在：（依赖）控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。依赖注入，即组件之间的依赖关系由容器在运行期决定，形象的来说，即由容器动态的将某种依赖关系注入到组件之中
起到的主要作用是解耦
Struts 、 spring 、 Hibernate 在各层的作用
1 ） struts 负责 web 层 .
ActionFormBean 接收网页中表单提交的数据，然后通过 Action 进行处理，再 Forward 到对应的网页。
在 struts-config.xml 中定义 <action-mapping>, ActionServlet 会加载。
2 ） spring 负责业务层管理，即 Service （或 Manager).
1 ． service 为 action 提供统计的调用接口，封装持久层的 DAO.
2 ．可以写一些自己的业务方法。
3 ．统一的 javabean 管理方法
4 ．声明式事务管理
5. 集成 Hiberante
3 ） Hiberante ，负责持久化层，完成数据库的 crud 操作
hibernate 为持久层，提供 OR/Mapping 。
它有一组 .hbm.xml 文件和 POJO, 是跟数据库中的表相对应的。然后定义 DAO ，这些是跟数据库打交道的类，它们会使用 PO 。
在 struts+spring+hibernate 的系统中，
对象的调用流程是： jsp-> Action － > Service ->DAO ->Hibernate 。
数据的流向是 ActionFormBean 接受用户的数据， Action 将数据从 ActionFromBean 中取出，封装成 VO 或 PO,
再调用业务层的 Bean 类，完成各种业务处理后再 forward 。而业务层 Bean 收到这个 PO 对象之后，会调用 DAO 接口方法，进行持久化操作。
Linux 系统下 ssh 安全设置指南
Linux 系统下 ssh 安全设置指南
如果您仍然使用 telnet, 而不是 ssh, 则需要改变对本手册的阅读方式. 应当用 ssh 来取代所有的 telnet 远程登录。任何时候通过嗅探互联网通讯来获取明文密码都是相当简单的, 您应该采用使用加密算法的协议. 那么, 现在在你的系统上执行 apt-get install ssh。
鼓励您系统上的所有用户使用 ssh 取代 telnet, 或者更进一步, 卸载 telnet/telnetd. 另外您应该避免使用 ssh 以 root 身份登录, 其替代的方法是使用 su 或 sudo 转换成 root 用户。最后, /etc/ssh 目录下的 sshd_config 文件, 应当作如下修改, 以增强安全性：
ListenAddress 192.168.0.1
使得 ssh 只监听一个指定的接口, 如果你有多个(并不想在其上边获得 ssh 服务)接口, 或者将来会增加一块新网卡(但并不想通过它连接ssh服务).
PermitRootLogin no
尝试任何情况先都不允许 Root 登录. 如果有人想通过 ssh 成为 root, 需要两次登录, 并且root的密码现在仍不可能通过SSH暴力破解.
Listen 666
改变监听端口, 这样入侵者不能完全确定是否运行了sshd守护进程(事先警告，这是模糊安全的).
PermitEmptyPasswords no
空密码是对系统安全的嘲弄.
AllowUsers alex ref me@somewhere
只允许某些用户通过 ssh 访问主机. user@host 也可用于限制指定用户通过指定主机访问.
AllowGroups wheel admin
仅允许某个组的成员通过 ssh 访问主机. AllowGroups 和 AllowUsers 对于拒绝访问主机有同样的效果. 当称它们为 "DenyUsers" 和 "DenyGroups" 时不要觉得奇怪.
PasswordAuthentication yes
这完全取决于您的选择. 仅仅允许用户使用置于 ~/.ssh/authorized_keys 文件中的 ssh-keys 登录主机将更加安全. 如果要达到这种效果，将其设为 "no".
禁用所有的您不需要的认证方式, 如果您用不到, 例如 RhostsRSAAuthentication, HostbasedAuthentication, KerberosAuthentication 或 RhostsAuthentication(例如), 您应该将其禁用, 即使它们是缺省设置(参阅联机帮助 sshd_config(5)).
Protocol 2
禁用版本1协议, 因为其设计缺陷, 很容易使密码被黑掉. 更多信息, 参阅 ssh协议问题报告 或 Xforce 通告.
Banner /etc/some_file
为用户连接到 ssh 服务器增加一个标题(它将从文件读取), 在一些国家, 登入给定系统前, 给出未经授权或者用户监视警告信息, 将会受到法律的保护.
ssh配置错误导致oracle安装自检失败
现象描述：
安装oracle11g的时候，在自检过程中自检失败，抱错如下：
INFO:
The Runconfig command constructed is null
INFO: Since the option is to overwrite the existing /oracle/crs/cfgtoollogs/configToolFailedCommands file, backing it up
INFO: The backed up file name is /oracle/crs/cfgtoollogs/configToolFailedCommands.bak.4
SEVERE: OUI-25031:Some of the configuration assistants failed/cancelled. It is strongly recommended that you retry the configuration assistants at this time. Not successfully running any "Recommended" assistants means your system will not be correctly configured.
1. Check the Details panel on the Configuration Assistant Screen to see the errors resulting in the failures.
2. Fix the errors causing these failures.
3. Select the failed assistants and click the 'Retry' button to retry them.
告警信息：
Checking user equivalence...
User equivalence check failed for user "oracle".
Check failed on nodes: scu1a
抱错信息是等价性检查失败。
原因分析：
确认主机备机的root oracle用户都能够ssh不输入密码登录到对方。同时必须注意，root oracle用户也能够ssh不输入密码登录本机（容易忽略的地方）。这里出现问题，就是由于scu1a/scu1b没有ssh自己本机所致。
处理过程：
以root,oracle用户分别ssh自身，第一次登陆需要输入密码，以后则不再需要。然后再次执行Oracle的安装，自检通过。
建议与总结：
ssh信任关系不仅要与对端节点做，而且要与本身节点做一次。
ssh测试
package com.airline.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.airline.pojo.User;
import com.airline.service.UserService;
public class UserServiceTest {
/**
* @param args
*/
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext(
"applicationContext.xml");
UserService us = (UserService) ac.getBean("userService");
User user = new User();
user.setUserName("wsr1");
user.setUserRealName("王山然");
user.setPassword("1234567");
user.setAge(12);
user.setAddress("南京");
user.setEmail("wsr@126.com");
user.setPasswordQuestion("我的生日");
user.setMobileNum("13956174522");
us.register(user);
关于SSH框架整合的配置文件
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<!-- 字节码转换过滤器 -->
<filter>
<description>字节码转换</description>
<filter-name>CharsetFilter</filter-name>
<filter-class>com.airline.filter.SetCharsetFilter</filter-class>
</filter>
<!-- 登录验证过滤器 -->
<filter>
<description>登录验证</description>
<filter-name>LoginFilter</filter-name>
<filter-class>com.airline.filter.LoginFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CharsetFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>LoginFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>login.jsp</welcome-file>
</welcome-file-list>
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
struts-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd">
<struts-config>
<action-mappings>
<!-- **************************用户模块************************* -->
<!-- 用户注册 -->
<action path="/user/register" type="com.airline.action.UserManagerAction" parameter="register">
<forward name="registerSuccess" path="/users/user/registerSuccess.jsp"></forward>
<forward name="registerFailed" path="/users/user/reRegister.jsp"></forward>
<forward name="Failed" path="/users/user/registerFailed.jsp"></forward>
</action>
<!--用户登录 -->
<action path="/user/login" type="com.airline.action.UserManagerAction" parameter="login">
<forward name="loginSuccess" path="/index.jsp"></forward>
<forward name="loginFaild" path="/users/user/relogin.jsp"></forward>
</action>
</action-mappings>
<!-- 添加请求转发器，当有请求过来时，转发器会把请求交给spring容器中bean对应的action处理，action中的path与spring容器中bean的name要一致 -->
<controller
processorClass="org.springframework.web.struts.DelegatingRequestProcessor" />
<!-- 添加spring插件 -->
<plug-in
className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/spring_config/applicationContext.xml" />
</plug-in>
</struts-config>
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/airline</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>wsr112</value>
</property>
</bean>
<!-- 配制SessionFactory -->
<bean id="mySessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
<property name="mappingResources">
<list>
<value>com/airline/pojo/xml/Admin.hbm.xml</value>
<value>com/airline/pojo/xml/FlightSchedular.hbm.xml</value>
<value>com/airline/pojo/xml/Order.hbm.xml</value>
<value>com/airline/pojo/xml/PlaneModel.hbm.xml</value>
<value>com/airline/pojo/xml/User.hbm.xml</value>
<value>com/airline/pojo/xml/Flight.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
<!-- 配置事务管理器 -->
<bean id="myTransactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="mySessionFactory"/>
</property>
</bean>
<bean id="abstractService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
<property name="transactionManager">
<ref local="myTransactionManager"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<!--********************************* 用户管理模块*************************** -->
<!-- 用户DAO -->
<bean id="userDao" class="com.airline.dao.hbmimpl.UserDAOImpl">
<property name="sessionFactory">
<ref local="mySessionFactory"/>
</property>
</bean>
<!-- 用户ServiceTarget -->
<bean id="userServiceTarget" class="com.airline.service.springimpl.UserServiceImpl">
<property name="userDao">
<ref local="userDao"/>
</property>
</bean>
<!-- 用户Service -->
<bean id="userService" parent="abstractService">
<property name="proxyInterfaces">
<value>com.airline.service.UserService</value>
</property>
<property name="target">
<ref local="userServiceTarget"/>
</property>
</bean>
<!-- 配置UserActionBean -->
<!-- 注册用户 -->
<bean name="/user/register"
class="com.airline.action.UserManagerAction">
<property name="userService">
<ref local="userService"/>
</property>
</bean>
<!-- 用户登录 -->
<bean name="/user/login" class="com.airline.action.UserManagerAction">
<property name="userService">
<ref local="userService"/>
</property>
</bean>
</beans>
SSH框架分页
1.PageInfo
package com.airline.util;
/**
* 分页工具
*
* @author 王山然
*
*/
public class PageInfo {
/**
* 总页数
*/
private int totalPage = 1;
/**
* 前一页
*/
private int prePage = 1;
/**
* 下一页
*/
private int nextPage = 1;
/**
* 总记录数
*/
private int totalRec = 0;
/**
* 默认每页记录数
*/
private final int defaultPageSize = 10;
/**
* 每页记录数
*/
private int pageSize = defaultPageSize;
/**
* 当前页码
*/
private int pageIndex = 1;
/**
* 全部页码，从1开始
*/
private int[] pageNumbers;
/**
* 获得当前页码
*
* @return
*/
public int getPageIndex() {
return pageIndex;
}
/**
* 设置当前页码
*
* @param pageIndex
*/
public void setPageIndex(int pageIndex) {
this.pageIndex = pageIndex > 0 ? pageIndex : 1;
}
/**
* 获得下一页
*
* @return
*/
public int getNextPage() {
return nextPage;
}
/**
* 设置下一页
*
* @param nextPage
*/
public void setNextPage(int nextPage) {
this.nextPage = nextPage > this.totalPage ? this.totalPage : nextPage;
}
/**
* 获得每页记录数
*
* @return
*/
public int getPageSize() {
return pageSize;
}
/**
* 设置每页记录数
*
* @param pageSize
*/
public void setPageSize(int pageSize) {
this.pageSize = pageSize > 0 ? pageSize : 10;
}
/**
* 获得前一页
*
* @return
*/
public int getPrePage() {
return prePage;
}
/**
* 设置前一页
*
* @param prePage
*/
public void setPrePage(int prePage) {
this.prePage = prePage < 1 ? 1 : prePage;
}
/**
* 获得总页数
*
* @return
*/
public int getTotalPage() {
return totalPage;
}
/**
* 设置总页数
*
* @param totalPage
*/
public void setTotalPage(int totalPage) {
this.totalPage = totalPage > 0 ? totalPage : 1;
}
/**
* 获得总记录数
*
* @return
*/
public int getTotalRec() {
return totalRec;
}
/**
* 设置总记录数
*
* @param totalRec
*/
public void setTotalRec(int totalRec) {
this.totalRec = totalRec > -1 ? totalRec : 0;
}
/**
* 获得当前页码
*
* @return
*/
public int[] getPageNumbers() {
return pageNumbers;
}
/**
* 设置当前页码
*
* @param pageNumbers
*/
public void setPageNumbers(int[] pageNumbers) {
this.pageNumbers = pageNumbers;
}
}
2.pageDAO
package com.airline.dao;
import java.util.List;
import com.airline.util.PageInfo;
/**
* 分页查询接口
*
* @author 王山然
*
*/
public interface PageDAO {
/**
* 根据查询语句进行分页查询
*
* @param queryString
* @param parameters
* @param pageInfo
* @return
*/
public List findPagesByQuery(final String queryString,
final Object[] parameters, final PageInfo pageInfo);
}
3.pageDAOImpl
package com.airline.dao.hbmimpl;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.ScrollableResults;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.airline.dao.PageDAO;
import com.airline.util.PageInfo;
/**
* 分页查询
* @author 王山然
*
*/
public class PageDAOImpl extends HibernateDaoSupport implements PageDAO {
/**
* 根据查询语句进行分页查询
* @param queryString
* @param parameters
* @param pageInfo
* @return
*/
public List findPagesByQuery(final String queryString,
final Object[] parameters, final PageInfo pageInfo) {
return (List) getHibernateTemplate().execute(new HibernateCallback()//这里使用了匿名内部类
{
public Object doInHibernate(Session session)//Spring进行事务维护 省去每次创建session和关闭session
throws HibernateException {
Query query = session.createQuery(queryString);
if (parameters != null) {
for (int i = 0; i < parameters.length; i++) {
query.setParameter(i, parameters);
}
}
ScrollableResults sr = query.scroll();
sr.last();
int totalCount = sr.getRowNumber();
int startIndex = (pageInfo.getPageIndex() - 1)
* pageInfo.getPageSize();
query.setMaxResults(pageInfo.getPageSize());
query.setFirstResult(startIndex);
int totalRec = totalCount + 1;
pageInfo.setTotalRec(totalRec);
int totalPage = (totalRec % pageInfo.getPageSize() == 0) ? (totalRec / pageInfo
.getPageSize())
: (totalRec / pageInfo.getPageSize()) + 1;
int[] pageNumbers = new int[totalPage];
for (int i = 0; i < totalPage; i++) {
pageNumbers = (i + 1);
}
pageInfo.setPageNumbers(pageNumbers);
pageInfo.setTotalPage(totalPage);
pageInfo.setPageSize(pageInfo.getPageSize());
pageInfo.setPageIndex(pageInfo.getPageIndex());
pageInfo.setPrePage(pageInfo.getPageIndex() - 1);
pageInfo.setNextPage(pageInfo.getPageIndex() + 1);
return query.list();
}
}, true);
}
}
4.PageService
package com.airline.service;
import java.util.List;
import com.airline.dao.PageDAO;
import com.airline.util.PageInfo;
public interface PageService {
/**
* 查询所有订单
*
* @param pageInfo
* @return
* @throws Exception
*/
public List getAllOrders(PageInfo pageInfo) throws Exception;
/**
* 查询所有航班计划
*
* @param pageInfo
* @return
* @throws Exception
*/
public List getAllFlightSchedulars(PageInfo pageInfo) throws Exception;
/**
* 查询所有机型
*
* @param pageInfo
* @return
* @throws Exception
*/
public List getAllPlaneModels(PageInfo pageInfo) throws Exception;
/**
* 查询所有用户
*
* @param pageInfo
* @return
* @throws Exception
*/
public List getAllUsers(PageInfo pageInfo) throws Exception;
/**
* 查询某个用户的订单
*
* @param pageInfo
* @return
* @throws Exception
*/
public List getOrdersByUser(PageInfo pageInfo, String userName)
throws Exception;
/**
* 查询航班
*
* @param pageInfo
* @param fromAddress
* @param toAddress
* @param AirlineCompanyName
* @return
* @throws Exception
*/
public List getFlights(PageInfo pageInfo, String fromAddress,
String toAddress, String AirlineCompanyName) throws Exception;
/**
* 查询所有航班
*
* @param pageInfo
* @param fromAddress
* @param toAddress
* @param AirlineCompanyName
* @return
* @throws Exception
*/
public List getAllFlights(PageInfo pageInfo) throws Exception;
}
5.PageServiceImpl
package com.airline.service.springimpl;
import java.util.List;
import org.springframework.dao.DataAccessException;
import com.airline.dao.PageDAO;
import com.airline.service.PageService;
import com.airline.util.PageInfo;
/**
* 分页实现
*
* @author 王山然
*
*/
public class PageServiceImpl implements PageService {
PageDAO pageDAO;
/**
* 查询所有订单
*/
public List getAllOrders(PageInfo pageInfo) throws Exception {
List orders = null;
if (pageInfo == null)
pageInfo = new PageInfo();
try {
orders = pageDAO.findPagesByQuery("from Order", null, pageInfo);
} catch (DataAccessException e) {
e.printStackTrace();
}
return orders;
}
/**
* 查询所有航班计划
*/
public List getAllFlightSchedulars(PageInfo pageInfo) throws Exception {
List flightSchedulars = null;
if (pageInfo == null)
pageInfo = new PageInfo();
try {
flightSchedulars = pageDAO.findPagesByQuery("from FlightSchedular",
null, pageInfo);
} catch (DataAccessException e) {
e.printStackTrace();
}
return flightSchedulars;
}
/**
* 查询所有机型
*/
public List getAllPlaneModels(PageInfo pageInfo) throws Exception {
List planeModels = null;
if (pageInfo == null)
pageInfo = new PageInfo();
try {
planeModels = pageDAO.findPagesByQuery("from PlaneModel", null,
pageInfo);
} catch (DataAccessException e) {
e.printStackTrace();
}
return planeModels;
}
/**
* 查询所有用户
*/
public List getAllUsers(PageInfo pageInfo) throws Exception {
List users = null;
if (pageInfo == null)
pageInfo = new PageInfo();
try {
users = pageDAO.findPagesByQuery("from User", null, pageInfo);
} catch (DataAccessException e) {
e.printStackTrace();
}
return users;
}
/**
* 查询某个用户的所有订单
*
* @param pageInfo
* @return
* @throws Exception
*/
public List getOrdersByUser(PageInfo pageInfo, String userName)
throws Exception {
List orders = null;
String[] userNames = new String[] { userName };
if (pageInfo == null)
pageInfo = new PageInfo();
try {
orders = pageDAO.findPagesByQuery("from Order where user=?",
userNames, pageInfo);
} catch (DataAccessException e) {
e.printStackTrace();
}
return orders;
}
/**
* 查询航班
*
* @param pageInfo
* @param userName
* @return
* @throws Exception
*/
public List getFlights(PageInfo pageInfo, String fromAddress,
String toAddress, String AirlineCompanyName) throws Exception {
List flights = null;
String[] values = new String[] { "%" + fromAddress + "%",
"%" + toAddress + "%", "%" + AirlineCompanyName + "%" };
if (pageInfo == null)
pageInfo = new PageInfo();
try {
flights = pageDAO
.findPagesByQuery(
"from FlightSchedular where fromAddress like ? and toAddress like ? and airlineCompany like ?",
values, pageInfo);
} catch (DataAccessException e) {
e.printStackTrace();
}
return flights;
}
/**
* 查询所有航班
*/
public List getAllFlights(PageInfo pageInfo) throws Exception {
List flights = null;
if (pageInfo == null)
pageInfo = new PageInfo();
try {
flights = pageDAO.findPagesByQuery("from Flight", null, pageInfo);
} catch (DataAccessException e) {
e.printStackTrace();
}
return flights;
}
public PageDAO getPageDAO() {
return pageDAO;
}
public void setPageDAO(PageDAO pageDAO) {
this.pageDAO = pageDAO;
}
}
6.PageAction
package com.airline.action;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.MappingDispatchAction;
import com.airline.pojo.AirlineDate;
import com.airline.pojo.Flight;
import com.airline.pojo.FlightSchedular;
import com.airline.pojo.User;
import com.airline.service.PageService;
import com.airline.util.DateOperation;
import com.airline.util.PageInfo;
/**
* 分页Action
* @author 王山然
*
*/
public class PageAction extends MappingDispatchAction {
PageService pageService;
public PageInfo pageInfo = new PageInfo();
/**
* 查询所有的订单
* @param mapping
* @param form
* @param request
* @param response
* @return
*/
public ActionForward findAllOrders(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
List orders = new ArrayList();
try {
String page = request.getParameter("page");
if (page == null) {
page = "1";
}
pageInfo.setPageIndex(Integer.parseInt(page));
orders = pageService.getAllOrders(pageInfo);
if (orders.size() != 0) {
request.setAttribute("orders", orders);
request.setAttribute("pageInfo", pageInfo);
}
} catch (Exception ex) {
ex.printStackTrace();
}
return mapping.findForward("Success");
}
/**
* 查询所有的航班计划
* @param mapping
* @param form
* @param request
* @param response
* @return
*/
public ActionForward findAllFlightSchedulars(ActionMapping mapping,
ActionForm form, HttpServletRequest request,
HttpServletResponse response) {
List flightSchedulars = new ArrayList();
try {
String page = request.getParameter("page");
if (page == null) {
page = "1";
}
pageInfo.setPageIndex(Integer.parseInt(page));
flightSchedulars = pageService.getAllFlightSchedulars(pageInfo);
if (flightSchedulars.size() != 0) {
request.setAttribute("flightSchedulars", flightSchedulars);
request.setAttribute("pageInfo", pageInfo);
}
} catch (Exception ex) {
ex.printStackTrace();
}
return mapping.findForward("Success");
}
/**
* 查询所有的机型
* @param mapping
* @param form
* @param request
* @param response
* @return
*/
public ActionForward findAllPlaneModels(ActionMapping mapping,
ActionForm form, HttpServletRequest request,
HttpServletResponse response) {
List planeModels = new ArrayList();
try {
String page = request.getParameter("page");
if (page == null) {
page = "1";
}
pageInfo.setPageIndex(Integer.parseInt(page));
planeModels = pageService.getAllPlaneModels(pageInfo);
if (planeModels.size() != 0) {
request.setAttribute("planeModels", planeModels);
request.setAttribute("pageInfo", pageInfo);
}
} catch (Exception ex) {
ex.printStackTrace();
}
return mapping.findForward("Success");
}
/**
* 查询所有的用户
* @param mapping
* @param form
* @param request
* @param response
* @return
*/
public ActionForward findAllUsers(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
List users = new ArrayList();
try {
String page = request.getParameter("page");
if (page == null) {
page = "1";
}
pageInfo.setPageIndex(Integer.parseInt(page));
users = pageService.getAllUsers(pageInfo);
if (users.size() != 0) {
request.setAttribute("users", users);
request.setAttribute("pageInfo", pageInfo);
}
} catch (Exception ex) {
ex.printStackTrace();
}
return mapping.findForward("Success");
}
/**
* 查询某个用户的订单
* @param mapping
* @param form
* @param request
* @param response
* @return
*/
public ActionForward findOrdersByUser(ActionMapping mapping,
ActionForm form, HttpServletRequest request,
HttpServletResponse response) {
User user = null;
List orders = new ArrayList();
try {
HttpSession session = request.getSession(false);
user = (User) session.getAttribute("user");
String userName = user.getUserName();
String page = request.getParameter("page");
if (page == null) {
page = "1";
}
pageInfo.setPageIndex(Integer.parseInt(page));
orders = pageService.getOrdersByUser(pageInfo, userName);
if (orders.size() != 0) {
request.setAttribute("orders", orders);
request.setAttribute("pageInfo", pageInfo);
}
} catch (Exception ex) {
ex.printStackTrace();
}
return mapping.findForward("Success");
}
/**
* 查询航班
* @param mapping
* @param form
* @param request
* @param response
* @return
*/
public ActionForward findFlights(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
List flights = new ArrayList();
AirlineDate date = null;
AirlineDate startDate = null;//开始执行日期
AirlineDate endDate = null;//结束执行日期
AirlineDate today = new AirlineDate();
FlightSchedular flightSchedular = null;
HttpSession session = request.getSession(false);
try {
String fromAddress = request.getParameter("fromAddress");
if (fromAddress != null) {
if (fromAddress.equals("请选择")) {
fromAddress = "";
}
session.setAttribute("fromAddress", fromAddress);
}
String toAddress = request.getParameter("toAddress");
if (toAddress != null) {
if (toAddress.equals("请选择")) {
toAddress = "";
}
session.setAttribute("toAddress", toAddress);
}
String dateStr = request.getParameter("startDate");
if (dateStr != null) {
session.setAttribute("dateStr", dateStr);
}
String airlineCompany = request.getParameter("airlineCompany");
if (airlineCompany != null) {
if (airlineCompany.equals("所有")) {
airlineCompany = "";
}
session.setAttribute("airlineCompany", airlineCompany);
}
String page = request.getParameter("page");
if (page == null) {
page = "1";
}
pageInfo.setPageIndex(Integer.parseInt(page));
List<FlightSchedular> flightSchedulars = pageService.getFlights(
pageInfo, session.getAttribute("fromAddress").toString(),
session.getAttribute("toAddress").toString(), session
.getAttribute("airlineCompany").toString());
if (flightSchedulars.isEmpty()) {
return mapping.findForward("Failed");
}
Iterator<FlightSchedular> it = flightSchedulars.iterator();
while (it.hasNext()) {
flightSchedular = it.next();
startDate = DateOperation.getDateFromStr(flightSchedular
.getStartDate(), "-");
endDate = DateOperation.getDateFromStr(flightSchedular
.getEndDate(), "-");
date = DateOperation.getDateFromStr(session.getAttribute(
"dateStr").toString(), "-");
if (!date.before(startDate) && !date.after(endDate)) {//判断查询的日期是否在班期内
String[] schedular = flightSchedular.getSchedular().split(
",");
int j = date.getWeekDay();
for (int i = 0; i < schedular.length; i++) {
if (Integer.parseInt(schedular) == j) {//表示所查询的这一天有航班
flights.add(flightSchedular);
}
}
}
}
if (flights.size() != 0) {
request.setAttribute("flights", flights);
request.setAttribute("date", date);
request.setAttribute("today", today);
request.setAttribute("fromAddress", session.getAttribute(
"fromAddress").toString());
request.setAttribute("toAddress", session.getAttribute(
"toAddress").toString());
request.setAttribute("pageInfo", pageInfo);
return mapping.findForward("Success");
}
} catch (Exception ex) {
ex.printStackTrace();
}
return mapping.findForward("Failed");
}
/**
* 查询所有航班
* @param mapping
* @param form
* @param request
* @param response
* @return
*/
public ActionForward findAllFlights(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
List flights = new ArrayList();
try {
String page = request.getParameter("page");
if (page == null) {
page = "1";
}
pageInfo.setPageIndex(Integer.parseInt(page));
flights = pageService.getAllFlights(pageInfo);
if (flights.size() != 0) {
request.setAttribute("flights", flights);
request.setAttribute("pageInfo", pageInfo);
}
} catch (Exception ex) {
ex.printStackTrace();
}
return mapping.findForward("Success");
}
public PageInfo getPageInfo() {
return pageInfo;
}
public void setPageInfo(PageInfo pageInfo) {
this.pageInfo = pageInfo;
}
public PageService getPageService() {
return pageService;
}
public void setPageService(PageService pageService) {
this.pageService = pageService;
}
}
7.jsp页面
<%@ page language="java" import="java.util.*,com.airline.service.PlaneModelService,com.airline.service.FlightService,com.airline.service.springimpl.FlightServiceImpl,com.airline.service.springimpl.PlaneModelServiceImpl,com.airline.pojo.FlightSchedular,com.airline.pojo.AirlineDate,com.airline.util.PageInfo,com.airline.pojo.Flight,com.airline.pojo.PlaneModel,org.springframework.context.ApplicationContext,org.springframework.context.support.ClassPathXmlApplicationContext;" pageEncoding="utf-8"%>
<%
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>迅捷机票预订系统</title>
<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">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
</head>
<body bgcolor="#99ffcc">
<%
String nowPage ;
int total;
nowPage=request.getParameter("page");
if(nowPage==null)
{nowPage="1";
}
int curPage=Integer.parseInt(nowPage);
if((PageInfo)request.getAttribute("pageInfo") == null){
total = 1;
} else {
total = ((PageInfo)request.getAttribute("pageInfo")).getTotalPage();
}
%>
<a href="/airline/index.jsp">返回</a>
<h1 align="center">航班查询结果</h1>
<hr>
<font color="red" size=2>航程:</font>
<%AirlineDate date=(AirlineDate)request.getAttribute("date");
AirlineDate today=(AirlineDate)request.getAttribute("today");
String fromAddress=(String)request.getAttribute("fromAddress");
String toAddress=(String)request.getAttribute("toAddress");
%><font color="green" size=2>
<%=date.toString() %>
<%=fromAddress %> ---
<%=toAddress %>
</font>
<br>
<table align="center" border=1 bgcolor="#ccff66">
<tr>
<th>航空公司</th>
<th>航班号</th>
<th>出发地</th>
<th>目的地</th>
<th>起飞时间</th>
<th>到达时间</th>
<th>机型</th>
<th>头等舱</th>
<th>公务舱</th>
<th>经济舱
</th>
</tr>
<%
if(request.getAttribute("flights")!=null){
List<FlightSchedular> flightSchedulars=(List<FlightSchedular>)request.getAttribute("flights");
FlightSchedular fs=null;
Flight flight=null;
PlaneModel planeModel=null;
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
FlightService flightService=(FlightService)ac.getBean("flightService");
PlaneModelService planeModelService=(PlaneModelService)ac.getBean("planeModelService");
Iterator<FlightSchedular> it=flightSchedulars.iterator();
while(it.hasNext()){
fs=it.next();
%>
<tr>
<td align="center"><%=fs.getAirlineCompany() %></td>
<td align="center"><%=fs.getFlightNumber() %></td>
<td align="center"><%=fs.getFromAddress() %></td>
<td align="center"><%=fs.getToAddress() %></td>
<td align="center"><%=fs.getFromTime() %></td>
<td align="center"><%=fs.getToTime() %></td>
<td align="center"><%=fs.getPlaneModel() %></td>
<%if(date.before(today)){ %>
<td align="center">
<%=fs.getBasicPrice()*1.8 %>
</td>
<td align="center">
<%=fs.getBasicPrice()*1.3 %>
</td>
<td align="center">
<%=fs.getBasicPrice()*1.0 %>
</td>
<%}else{
flight=flightService.findFlightByFlightNumAndDate(fs.getFlightNumber(),date.simpleString());
System.out.println(flight);
if(flight!=null){//如果航班已经被预定过
if(flight.getRemainFCS()>=1){//头等舱还有座位
%>
<td align="center">
<a href="/airline/user/findFlight.do?flightNumber=<%=fs.getFlightNumber()%>&date=<%=date.simpleString() %>&cabinType=F" title="剩余座位数:<%=flight.getRemainFCS() %>"><%=fs.getBasicPrice()*1.8 %></a>
</td>
<%}else{ %>
<td align="center">
<%=fs.getBasicPrice()*1.8 %>
</td>
<%} %>
<%if(flight.getRemainBCS()>=1){ //公务舱还有座位%>
<td align="center">
<a href="/airline/user/findFlight.do?flightNumber=<%=fs.getFlightNumber()%>&date=<%=date.simpleString() %>&cabinType=B" title="剩余座位数:<%=flight.getRemainBCS() %>"><%=fs.getBasicPrice()*1.3 %></a>
</td>
<%}else{ %>
<td align="center">
<%=fs.getBasicPrice()*1.3 %>
</td>
<%}if(flight.getRemainECS()>=1){ //如果经济舱还有座位%>
<td align="center">
<a href="/airline/user/findFlight.do?flightNumber=<%=fs.getFlightNumber()%>&date=<%=date.simpleString() %>&cabinType=E" title="剩余座位数:<%=flight.getRemainECS() %>"><%=fs.getBasicPrice()*1.0 %></a>
</td>
<%}else{ %>
<td align="center"><%=fs.getBasicPrice()*1.0 %></td>
<%} %>
<%}else{ //如果还没有被预定
planeModel=planeModelService.getPlaneModelByModel(fs.getPlaneModel());
//System.out.println(fs.getPlaneModel());
%>
<td align="center">
<a href="/airline/user/findFlight.do?flightNumber=<%=fs.getFlightNumber()%>&date=<%=date.simpleString() %>&cabinType=F" title="剩余座位数:<%=planeModel.getFCS() %>"><%=fs.getBasicPrice()*1.8 %></a>
</td>
<td align="center">
<a href="/airline/user/findFlight.do?flightNumber=<%=fs.getFlightNumber()%>&date=<%=date.simpleString() %>&cabinType=B" title="剩余座位数:<%=planeModel.getBCS() %>"><%=fs.getBasicPrice()*1.3 %></a>
</td>
<td align="center">
<a href="/airline/user/findFlight.do?flightNumber=<%=fs.getFlightNumber()%>&date=<%=date.simpleString() %>&cabinType=E" title="剩余座位数:<%=planeModel.getECS() %>"><%=fs.getBasicPrice()*1.0 %></a>
</td>
<%} %>
<%} %>
</tr>
<%}
}
%>
</table><br><br>
<center>
<a href="${pageContext.request.contextPath }/user/page/findFlights.do?page=1">首页</a> |
<a href="${pageContext.request.contextPath }/user/page/findFlights.do?page=<%=curPage-1<=0?1:curPage-1%>">上一页</a> |
<a href="${pageContext.request.contextPath }/user/page/findFlights.do?page=<%=curPage+1>total?total:curPage+1%>">下一页</a> |
<a href="${pageContext.request.contextPath }/user/page/findFlights.do?page=<%=total %>">末页</a>
当前第<%=curPage %>页 转到第 <select id="page" onchange="window.location.href='${pageContext.request.contextPath }/user/page/findFlights.do?page='+document.getElementById('page').value;"> <%
for(int toPage = 1; toPage<=total; toPage++) {
%>
<option value = <%=toPage%>
<%if(toPage==curPage){ %>
selected
<%} %>
>
<%=toPage %>
</option>
<%
}
%>
</select> 页
共<%=total%>页
</center>
</body>
</html>
Annotation的SSH整合开发
基于Annotation的SSH整合开发，其实，并没有我当初想像中那么顺利。真正去做的时候，才发觉有许多问题。但不要紧，探索一下吧。在探索过程中学到知识，才是最重要的。
言归正传，现在，我们加入Spring的支持：把spring-framework-2.5.5/dist中的spirng.jar引进我们项目的lib目录来，还要添加/lib/aspectj/下的两个jar包，以支持切面编程。
必要的配置文件还是要的：
applicationContext-common.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<!-- 配置SessionFactory,由Spring容器来管理Hibernate -->
<!-- 非Annotation时,使用org.springframework.orm.hibernate3.LocalSessionFactoryBean,
它注入实体类的方式是setMappingResources(),而Hibernate Annotation所用的映射方式
不是mapping resource,而是mapping class,这就要用到LocalSessionFactoryBean的子类
AnnotationSessionFactoryBean了.因为AnnotationSessionFactoryBean它支持实体的注入
方式setAnnotatedClasses,即对应Hibernate中的mapping class.参见这两个类的源代码. -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 配置事务的传播特性 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="delete*" propagation="REQUIRED" />
<tx:method name="*" read-only="true" />
</tx:attributes>
</tx:advice>
<!-- 那些类的哪些方法参与事务 -->
<aop:config>
<aop:pointcut id="allServiceMethod" expression="execution(* com.rong.dao.*.*.*(..))" />
<aop:advisor pointcut-ref="allServiceMethod" advice-ref="txAdvice" />
</aop:config>
<!-- 使Spring关注Annotation -->
<context:annotation-config/>
<!-- 让Spring通过自动扫描来查询和管理Bean -->
<context:component-scan base-package="com.rong"/>
<!--
<bean id="userDao" class="com.rong.dao.UserDaoBean">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<bean id="userService" class="com.rong.service.UserServiceBean">
<property name="userDao" ref="userDao"/>
</bean>
-->
</beans>
关键的两点：
<!-- 使Spring关注Annotation -->
<context:annotation-config/>
<!-- 让Spring通过自动扫描来查询和管理Bean -->
<context:component-scan base-package="com.rong"/>
这样配置之后，就省去了上面注释掉的DAO层和Service层等配置代码。是不是很方便呢。
关于这一部分的XML代码，我们下面还会作解释。
来开发我们的DAO层吧,接口如下：
package com.rong.dao;
import java.util.List;
import com.rong.entity.User;
public interface UserDao {
public void save(User user);
public void delete(int id);
public void update(User user);
public List<User> query();
public User get(int id);
}
DAO层的实现类：
package com.rong.dao;
import java.util.List;
import org.springframework.stereotype.Repository;
import com.rong.entity.User;
@Repository("userDao") //声明此类为数据持久层的类
public class UserDaoBean extends MyHibernateDaoSupport implements UserDao {
public void save(User user){
super.getHibernateTemplate().save(user);
}
public void delete(int id){
super.getHibernateTemplate().delete(super.getHibernateTemplate().load(User.class, id));
}
public void update(User user){
super.getHibernateTemplate().update(user);
}
@SuppressWarnings("unchecked")
public List<User> query(){
return super.getHibernateTemplate().find("from User");
}
public User get(int id){
return (User)super.getHibernateTemplate().get("from User", id);
}
}
大家可以看到，我们这里继承的不是HibernateDaoSupport,而是我自己编写的一个类MyHibernateDaoSupport。其代码如下：
package com.rong.dao;
import javax.annotation.Resource;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
public class MyHibernateDaoSupport extends HibernateDaoSupport {
@Resource(name="sessionFactory") //为父类HibernateDaoSupport注入sessionFactory的值
public void setSuperSessionFactory(SessionFactory sessionFactory){
super.setSessionFactory(sessionFactory);
}
}
我们之所以要改写HibernateDaoSupport，是因我为，我们要为DAO层的类注入SessionFactory这个属性。以后，我们开发的DAO类，就可以直接重用这个MyHibernateDaoSupport了。其实，这样做是相当于配置文件方式的代码：
<bean id="userDao" class="com.rong.dao.UserDaoBean">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
我们既然要用annotation代替XML文件的，就要让它也能像原来那样使用sessionFactory,故为MyHibernateDaoSupport注入SessionFactory。子类继承这个类时，也继承其Annotation。这样，我们就可以实现SessionFactory的注入了。
到现在，我们再回过头来看applicationContext-common.xml中的
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
我们平时开发Hibernate与Spring整合时，常常会用到org.springframework.orm.hibernate3.LocalSessionFactoryBean来提供SessionFactory，而我们这里却要改成org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean。其实是这样的，我们在Hibernate.cfg.xml中配置的实体类映射的方式如下：（详见基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发 (1) ）
<!--
<mapping resource="com/rong/entity/User.hbm.xml"/>
-->
<!-- 在Hibernate中注册User实体类,区别于上面注释掉的resource写法 -->
<mapping class="com.rong.entity.User"/>
要使Hibernate的实体类支持注解，去掉xxx.hbm.xml的文件，故我们所用的是mapping class方式，不是mapping resource的方法。然而，LocalSessionFactoryBean这个类，它采用的实体类映射方式是mapping resource，（详情可参见LocalSessionFactoryBean这个类的源代码）。如果我们在配置中仍然用这个类的话，Hibernate与Spring整合时，就会报错。而AnnotationSessionFactoryBean这个类在LocalSessionFactoryBean的基础上添加了mapping class方式实现实体类映射（详见AnnotationSessionFactoryBean类的源代码）。
我们再来看Service层的代码：（接口比较简单，节约篇幅就不列出了）
package com.rong.service;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.rong.dao.UserDao;
import com.rong.entity.User;
@Service("userService") //声明此类为业务逻辑层的类
public class UserServiceBean implements UserService {
@Autowired
private UserDao userDao;
public void save(User user){
userDao.save(user);
}
}
我们用到的注解上面一般都作了注释，就不多叙。@Autowired和@Resource功能差不多，就是把对象注入，相当于<bean>配置的功能。
好，就开发到这样，是不是忘记了什么？记得要配置web.xml，部分代码如下：
<!-- 修改Spring配置文件的路径 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:applicationContext-*.xml</param-value>
</context-param>
<!-- 配置Spring -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
是不是真的成功了？用Junit测试一下吧，我测试过是没问题的，由于篇幅，Junit的测试代码就不贴出来了。自己练习一下吧！
其实，到现在为止，我们发觉我们的XML配置文件还是很多。其实，这样想想，上一阶段我们省去了xxx.hbm.xml这类的文件，这一阶段，我们少去了<bean id="" class=""><property name="" ref="">这样的配置项。而这些，正是我们项目开发中，大量使用的配置。而只要书写简单的Annotation注解，就可以省去这样，我们何乐而不用。而那些我们保留的XML配置文件（如：数据库连接，事务），这样是写死的，一个项目就写一次或复制过来用，我们保留它又何妨？
Secure Shell(SSH)简介
昨天在搭建印尼环境中的icnfg服务器的时候，在杀掉一些进程以后，突然跳板机登不上去了，多次尝试以后，都弹出“network error：refuse connected！”的提示信息。最后在经过华为深圳的开发定位，方才知道是SSH服务停掉了，必须要登录跳板机或在图形化界面（我用的是Xmanage）上重启SSH服务。oa.headware.cn:8888% X2 m2 G( /# h7 Y' l7 H
利用今天休息，查阅了一些关于SSH服务器的知识。现做了一下简单的总结，供大家分享。8 Y$ /0 f& p; j, b3 n
一.什么是SSH
传统的网络服务程序如FTP、POP、Telent在传输数据的过程中采用明文传送数据（包括用户账号和口令），而通过窃听等网络攻击手段就能够非常容易地截获这些数据。另外，还很容易受到“中间人”（一种攻击方式）的攻击。所谓“中间人”的攻击方式，就是“中间人”冒充真正的服务器接收传送的数据，然后再冒充发送端把数据传送给真正的服务器。这样服务器和发送端的数据经“中间人”转手做了手脚之后，就会出现严重的问题。
SSH是英文Secure Shell的简写。通过使用SSH，可以把所传送的数据进行加密，在这样可以有效避免“中间人”这种攻击方式，而且也能够防止DNS和IP欺骗，还有一个额外的好处就是将传输的数据进行压缩，所以可以加快传输速度。正是因为SSH的很多优点，可以用来取代Telnet，并可以为FTP、POP、PPP等提供一个安全的通道。
另外，SSH在运行方式上不像其他的TCP/IP应用，它是工作于自己的基础之上的。虽然可以通过tcpd（从inetd上运行启动）来运行SSH，但这是完全没有必要的。
二.SSH协议 B) p4 a& p, _8 Y+ N @0 R
SSH协议是建立在应用层和传输层基础上的安全协议，主要由以下三部分组成：
传输层协议 提供诸如认证、信任和完整性检查等的安全措施。此外，还可以任意的压缩数据。通常，这些传输协议都建立在面向连接的TCP数据流之上。
用户认证协议层 实现服务器和客户端之间的身份认证，运行在传输层协议之上。
连接协议层 分配多个加密通道于一些逻辑通道上，它运行在用户认证协议层之上。8 z7 l1 p3 e" M6 i$ F: J( i
这三部分共同实现SSH安全保护机制。
三.SSH的安全验证' T; _6 s' o F
SSH提供两种级别的安全验证。
第一种是基于口令的安全验证。只要知道自己的账号和口令，就可以登录到远程主机，并且所有数据都会被加密。但是，这种验证方式不能保证你正在连接的服务器就是你的目的服务器，即受到“中间人”这种攻击方式的攻击。
第二种是基于密钥的安全验证。也就是必须为自己创建一对密钥，并把公钥放在目的服务器上。如果你连到SSH服务器上，客户端软件就会向服务器发起请求，请求你的密钥进行安全验证。服务器接到请求后，就会在你位于该服务器的目录下寻找你的公钥，并与发送过来的公钥进行比较。如果一致，服务器则用公钥加密质询并发送给客户端，客户端接收到质询之后就可以用密钥解密再发往服务器。这种安全验证方式使得“中间人”攻击方式成为不可能，因为它没有你的私人密钥。
四.SSH常见的应用
首先，SSH常见的应用就是取代传统的Telnet、FTP等网络应用程序，通过SSH登录到远程主机执行想要的工作或命令。它提供了很强的验证机制和通讯环境。. {+ Q9 k. Y9 O7 W
其次，通过使用SSH可以在本地主机和远程服务器之间设置“加密通道”。这样设置的“加密通道”可以跟常见的Pop、X、Linuxconf应用程序相结合，提供安全保障。
关于SSH的知识有很多，今天就写到这里了。希望通过以上的简单介绍，大家可以对SSH有个初步的印象。最后，想和大家说的就是，在项目过程中，出现了问题不要紧张，尤其是当周围的同事也没有类似经验的时候，就更要想办法来定位问题，逐步回想哪一步操作可能造成现在的结果。如果自乱阵脚的话，接口人对自己的印象会打折扣的哦^_^
搭建SSH集成工程
//搭建SSH集成工程：oa.headware.cn:88882 L& L/ U& n, A, t2 T) c; i. g
//1.建立普通web工程，导入SSH框架所需的jar文件（79个文件包含mysql驱动包）。
* B8 k% [1 b% e
//2.建立applicationContext.xml(<?xml version="1.0" encoding="UTF-8"?>( P" m5 Q( F& O
<beans xmlns="http://www.springframework.org/schema/beans"/ |. E- S7 W# i" S+ P* d8 @2 ?
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"知识管理频道5 M. O1 t7 i) Y8 }/ `$ h1 M
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
</beans>)文件与struts-config.xml(<?xml version="1.0" encoding="UTF-8"?>% i3 ~( {& n) N8 z7 J
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd">
)文件。
//3.在myeclipse创建数据库连接。oa.headware.cn:88888 c6 k" l4 L: R$ v' f5 v. q! k" P: N
//4.在applicationContext中配置数据库连接(<bean id="con" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName"oa.headware.cn:8888/ r v" _; H) i" Q2 ?: p
value="com.mysql.jdbc.Driver">
</property>
<property name="url"
value="jdbc:mysql://localhost:3306/test?characterEncoding=GBK">
</property>
<property name="username" value="root"></property>" I/ f) t$ F5 C. J) Q4 }
<property name="password" value="123"></property>
</bean>)。
6 g: l1 ?" }& s7 p2 [
//5.在applicationContext中配置HibenateSessionFactory.: b9 P6 ]3 n8 C7 m
//6.在工程中创建po包。oa.headware.cn:88882 R" v% v2 Z7 P7 S; x5 ~4 {
//7.在po包中创建实体与实体的映射文件。
//8.在工程中创建dao包。知识管理频道; b! C/ Z+ ]7 E! B- x0 C
. B: t ]4 ^+ |4 }% U6 ?
//9.在dao包中创建一个类（UserDao）继承org.springframework.orm.hibernate3.support.HibernateDaoSupport。
% j/ X: B- I. Q# J* p
//10.在UserDao中创建save（）方法(使用getHibernateTemplate().save();).# b# J6 ?- H$ r! _
//11.在applicationContext.xml文件中配置实体的指向(<property name="mappingResources">
<list>oa.headware.cn:88889 K& Q0 C* T% }) F% F
<value>po/Users.hbm.xml</value>oa.headware.cn:88889 t1 W+ t2 b ^2 B8 R, t
</list>
</property>; a: b& o9 f ]; r. U5 q. I( T
</bean>知识管理频道6 d. _9 u5 N& F% v
<bean id="UsersDAO" class="dao.UsersDAO">
<property name="sessionFactory">3 /% h2 x b: l2 s/ [1 s
<ref bean="sessionFactory"></ref>( C7 r# B# ], E, H
</property>
</bean>)。
//12.在UserDao中创建Mian()进行测试(public static void main(String[] args) {
ApplicationContext ctx = new FileSystemXmlApplicationContext("WebRoot/WEB-INF/applicationContext.xml");
UsersDAO user = (UsersDAO)ctx.getBean("UsersDAO"); . }6 T5 X- @- F% Y3 ~! x6 k
Users users = new Users();" m; H, Q& r& O/ W/ F1 d
users.setUsername("lbj");oa.headware.cn:8888/ X h7 P/ /, F# ?3 }+ g1 E
users.setUpwd("123");
user.save(users);
}).
//13.在工程中创建servlet包并在包下创建并总控器类并在工程中的web.xml文件中配置总控制器(servlet和mapping各一对)(<servlet>
<servlet-name>action</servlet-name>oa.headware.cn:88883 V# V% r: v5 ^9 X# |
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>6 a( W) ~! N$ Z. s/ c H
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<init-param>
<param-name>debug</param-name>
<param-value>3</param-value>! t& ?/ q% V, f, X7 s' v3 s) K3 g3 h
</init-param>: [: K( {" M, h1 N0 w
<init-param>
<param-name>detail</param-name>知识管理频道5 |& X. S6 d0 q+ I+ M! m( R
<param-value>3</param-value>oa.headware.cn:8888; R5 C; }: D4 e
</init-param>! S3 p, B( q, F7 ]* H/ l$ B
<load-on-startup>0</load-on-startup># v9 W3 b- X; q: F" W
</servlet>
<servlet-mapping>oa.headware.cn:88882 O- /" R+ P4 s9 B) O8 V" m
<servlet-name>action</servlet-name>知识管理频道* t1 w* _5 @- r/ c. w1 ?
<url-pattern>*.do</url-pattern>! y" }/ V) M4 I5 Z9 H
</servlet-mapping>).- Q" u1 a; c& D
: g+ ^5 M2 b2 d( m, p: N/ G' o; Q
//14.在工程中创建action(com.demo.sturts.action可以使用工具中右键的source中抽取方法选项快速创建save())与actionform(com.demo.sturts.form).
2 {/ u7 Z" p% v% F
//15.struts.xml文件中配置struts-config信息(<struts-config>
<data-sources />知识管理频道) A1 i- D8 q6 A s
<form-beans >. z+ i9 b' c. a* g
<form-bean name="usersForm" type="com.demo.struts.form.UsersForm" />oa.headware.cn:8888/ R% N3 D; v" ~0 ~
</form-beans>
知识管理频道4 v% j6 V& S& v/ ~+ s/ z3 ~6 F
<global-exceptions />
<global-forwards />
<action-mappings >
<action
attribute="usersForm"
input="/form/users.jsp") ]5 A2 B, ^. c# X- }9 s
name="usersForm"oa.headware.cn:8888+ Q' T; g5 D5 _* p, W0 W+ V
path="/users"
scope="request" X1 ?6 l$ F0 }
type="org.springframework.web.struts.DelegatingActionProxy"/>* /1 j. W! U" `' t$ u
2 B! |) I8 R% H6 _
</action-mappings>
' m5 h( i9 k% K# R8 }
<message-resources parameter="com.demo.struts.ApplicationResources" />
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">8 j1 U& ^$ i' N6 ]3 R. x- V8 d
<set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />( n! E* g" }+ l/ ^- S& r# O
</plug-in>
</struts-config>
)
//16.在工程中创建service包并创建服务类。oa.headware.cn:8888( c7 {* /) S0 Z; ?. K( P
//17.编写jsp页面进行测试。
SSH应用篇－－如何不使用密码登录另一个用户
有些时候，我们在复制/移动文件到另一台机器时会用到scp，因为它比较安全。但如果每次
都要输入密码，就比较烦了，尤其是在script里。不过，ssh有另一种用密钥对来验证的方5 P2 P+ k( K1 Q9 X5 w( U
式。下面写出我生成密匙对的过程，供大家参考。5 D+ x4 I4 o. v9 M+ S
第一步：生成密匙对，我用的是rsa的密钥。使用命令 "ssh-keygen -t rsa"( _! z5 a+ P3 J
CODE:[Copy to clipboard] [user1@rh user1]$ ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/user1/.ssh/id_rsa):& x, }+ @7 |. B9 t H& m' j. K
Created directory '/home/user1/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:* q1 Q: Q9 ~; P
Your identification has been saved in /home/user1/.ssh/id_rsa.知识管理频道% k% B# u4 B: J$ Q4 e) l) v( k2 z
Your public key has been saved in /home/user1/.ssh/id_rsa.pub.& |& f" U9 o1 }2 i1 E# {
The key fingerprint is:) Z' @: T, ~- Q/ L
e0:f0:3b:d3:0a:3d:da:42:01:6a:61:2f:6c:a0:c6:e7 user1@rh.test.com
[user1@rh user1]$
生成的过程中提示输入密钥对保存位置，直接回车，接受默认值就行了。接着会提示输入一oa.headware.cn:8888" x7 C1 ^2 X7 J8 u8 l
个不同于你的password的密码，直接回车，让它空着。当然，也可以输入一个。(我比较懒
，不想每次都要输入密码。) 这样，密钥对就生成完了。
其中公共密钥保存在 ~/.ssh/id_rsa.pub
私有密钥保存在 ~/.ssh/id_rsa. K, B V; Y. e, Y' f
然后改一下 .ssh 目录的权限，使用命令 "chmod 755 ~/.ssh"
( ~: a% c/ _# Z' I3 u1 m
CODE:[Copy to clipboard] [user1@rh user1]$ chmod 755 ~/.ssh
[user1@rh user1]$知识管理频道- z) k/ ?+ f, m7 H9 D
之后把这个密钥对中的公共密钥复制到你要访问的机器上去，并保存为
~/.ssh/authorized_keys.
知识管理频道0 h2 m7 p# b' i6 P5 o; }" q5 O# u
CODE:[Copy to clipboard] [user1@rh user1]$ scp ~/.ssh/id_rsa.pub rh1:/home/user1/.ssh/authorized_keys
[email=user1@rh1]user1@rh1's[/email] password:
id_rsa.pub 100% 228 3.2MB/s 00:00
[user1@rh user1]$
之这样就大功告成了。之后你再用ssh scp sftp 之类的访问那台机器时，就不用输入密码
了，用在script上更是方便。
注意:
.ssh目录的权限.
若有多个SFTP都要到同一台机器上传数据.那么目标机器的authorized_keys文件中包含多个私钥就可以了. cat a b > authorized_keys知识管理频道1 F/ i/ p$ M3 O! l/ M* A" k; T
此方法亦可用在多机批量协作,批量完成后,通过SFTP传输一个完成文件到目标机器,以完成多机协作.
OpenSSH 扫盲帖
传统的unix网络程序，例如telnet、rsh、rlogin或者rexec以及ftp等，# a2 p& {1 Q* x9 d
都是用明文的形式传递用户名、口令和相关信息，缺少安全性。如果通过Internet传输一个敏感的文件，入侵者就很有可能将该文件截获并且看到其中的数据。SSH（Secure Shell，安全Shell）是一种通用的、功能强大的、基于软件的网络安全性解决方案。计算机每次向网络发送数据时，SSH都会自动对其进行加密，当数据到达目的地时，SSH自动对加密的数据进行解密（译码），结果整个加密过程都是透明的，这样的话就有效的防止了窃取、劫取和网络攻击，另外SSH也提供了很多的安全隧道和各种的认证方法。SSH具有客户端/服务端的体系结构。SSH服务器程序通常都是由系统管理员安装并运行，可以接受或者拒绝到达自己主机的连接。然后用户运行SSH客户端程序（这通常时在其他的计算机上执行的）来对SSH服务器发出请求。一般SSH的服务器端软件包有OpenSSH，SSH1和SSH2，其中OpenSSH时免费的SSH协议版本，时OpenBSD项目的产品，同时支持SSH1.3、1.5和2.0。基于目前的网络的安全性要求，需要在目前的IN中采用SSH来对网络的安全进行加固，需要IN中的相关的子系统支持SSH －
