重新构建SSH框架 SSH框架整合基础

项目的整体框架都好了（虽然相当的不满意这个框架，因为都还残留着servlet时候的影子）

今天重新构建这个框架，重新熟悉一遍，看看是否能成功。（类代码主要靠复制）

一、创建主要的页面

/admin/user/user_ooxx.jsp

/index/ooxx.jsp

login.jsp

二、添加Struts框架，

yourcompany  --->改成相对应的公司名，项目名就OK了。（当然，其他选项也是要理解的）

三、配置struts-config文件，可以手动配，也可以通过图形化界面来配置。

主要就是页面跳转的基本一个框架了。

四、写formbean，在FormBean中写入页面传递过来的参数，和get    set 方法。例如：

private String name;
	private String password;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

loginForm 还是 userForm中都可以写（Struts2直接在Action中了，没有把FormBean分出来）

这步可以做到，页面传递过来的参数接收，并判断，返回页面了。

五、业务逻辑的开始

1.（抽象）业务逻辑层 com.jake.oa.service.IUserService.java

2.（实现）业务逻辑层 com.jake.oa.service.UserServiceImpl.java

六、View层和Control层的对接

Struts为Control层框架，主要就是负责View层和Control层的对接工作，

这时候，可以在Action中写一些方法来实现View和Control层的跳转工作。（例如，在Action中使用Formbean来取得数据，判断数据，跳转）

例如：

public ActionForward execute(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {
		LoginForm loginForm = (LoginForm) form;// TODO Auto-generated method stub
		Hashtable<String, Object> temp = new Hashtable<String, Object>();
		temp = this.login(request, response, temp, loginForm);
		if(temp != null){
			return mapping.findForward(temp.get("url")
					.toString().trim());
		}
		return null;
	}	
	public Hashtable<String, Object> login(HttpServletRequest request,
			HttpServletResponse response, Hashtable<String, Object> temp,
			LoginForm loginForm){
		    String name = loginForm.getName() == null ? "" 
		    		: loginForm.getName().trim();
		    String password = loginForm.getPassword() == null ? ""
		    		: loginForm.getPassword().trim(); 
		    if("admin".equals(name) && "123".equals(password)){
		    	temp.put("loginName", name);
		    	request.getSession().setAttribute("temp", temp);
		    	temp.put("url", "success");
		    }else{
		    	temp.put("massage", "");
		    	temp.put("url", "error");
		    }
		return temp;
	}

当然，注意红色这段，这里需要和Struts-config.xml文件映射配对起来，才能正确地跳转到想到到达的页面。

七、其他页面，及业务逻辑的对接

（这个时候，可以做其他页面的内容）注意，基本上所有的连接跳转都通过 .do的形式完成，基本上过了一遍业务的处理（例如登入验证之类的）。

八、Spring IOC的结合

首先：当然时添加Spring框架

注意：MyEclipse各个版本添加2.5所添加的jar包是不同的，额外6.6勾选上Spring2.5Web Libraries 并且 将JAR Library Installation 选择为Copy checked Library contents to project folder （TLDs always copied） 目录为 /WebRoot/WEB-INF/lib下 ,曾试过将applicationContext放在同src同目录下，结果失败了，移动到lib下后成功。

选 Next >

根据实际需求，选择Enable AOP。这个项目中不用，所以不勾选。

Bean configuration type 选择new   -----> finished就OK啦。

九、将IOC进行到底，（何谓IOC，何谓DI请参阅本人前面的日记）

就目前我学习Spring的理解水平，Spring IOC给我带来了两个好处。 节约初始化对象的时间，对面向接口的编程支持的实现。

IoC中有好多要注意的地方，例如：注入方式，Spring提供了三种的注入方式，不过，正常人都只用一种（虽然，HibernateTemple 貌似三种都实现了），我们只用一种，设值注入，也就是get 和set方法的注入。

这里我的想法时分为两部分：

一、逻辑部分（代码部分）

二、Spring或Struts配置部分。

IoC的思想要求我们，提前知道要初始化的类，

首先我们先看两段配置，这是在Struts中配置的，让Spring可以管理Struts的类的一个配置信息

  <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
  <set-property value="/WEB-INF/applicationContext.xml" property="contextConfigLocation"/>  
  </plug-in>

这段，是Struts1中（Struts2版本的SSH预计将会在8月份实践）将Action交与Spring管理是的DelegatingActionProxy的配置

<action
      name="userForm"
      path="/user"
      scope="request"
      type="org.springframework.web.struts.DelegatingActionProxy"
      validate="false">
      <forward name="success" path="/admin/user/usersuccess.jsp" />
      ...
    </action>

这样，就将user 的userAction交与Spring的IoC容器管理了。（类似Action都能交与Spring管理）

接着我们看Spring的配置

<bean name="/user" class="com.sms.struts.action.UserAction">
		<!-- 有property的说明是需要依赖的 -->
		<property name="iuserService">
			<!-- 指定id为iuserService的bean类，这个bean类必定也定义在此ApplicationContext.xml中 -->
			<ref bean="iuserService" />
		</property>
</bean>

<bean id="iuserService" class="com.sms.service.ipml.UserServiceImpl">
		<property name="idaoToolService">
			<ref bean="idaoToolService"/>
		</property>
</bean>
<!--这个要加载Hibernate之后的 -->
<bean id="idaoToolService" class="com.sms.idao.impl.DaoToolServiceImpl">
		<!-- property 的名字必须和ref 一样???? -->
		<property name="sessionFactory">
			<ref bean="sessionFactory" />
		</property>
</bean>
......

于是乎，在完成上面部分的Spring配置

看看IDaoToolService这个数据库操作接口

import java.util.List;

import org.hibernate.HibernateException;

public interface IDaoToolService {

	public List quesr(String hql) throws HibernateException;

	public void save(Object obj) throws HibernateException;

	public void update(Object obj) throws HibernateException;
	
	public void saveOrUpdate(Object obj) throws HibernateException;
	
	public void delete(Object obj) throws HibernateException;	

}

然后就是在代码部分了，--即get set 方法，让spring注入的类赋值给某个类。先看UserAction

public class UserAction extends Action {
	/*
	 * Generated Methods
	 */
	private IUserService iuserService;

	public IUserService getIuserService() {
		return iuserService;
	}

	public void setIuserService(IUserService iuserService) {
		this.iuserService = iuserService;
	}

	/**
	 * Method execute
	 * 
	 * @param mapping
	 * @param form
	 * @param request
	 * @param response
	 * @return ActionForward
	 */
	public ActionForward execute(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {
        。。。。。。 

再看看数据库操作接口实现类。（这里没有get set？请参阅上几篇博文，关于继承HibernateDaoSupport的注入）

public class DaoToolServiceImpl extends HibernateDaoSupport implements
		IDaoToolService {

	/**
	 * 
	 * 查询数据库信息
	 * @param String hql
	 * @return List list
	 */

	public List quesr(String hql) throws HibernateException {		
		return this.getHibernateTemplate().find(hql);
	}

	
	/**
	 * 删除对象
	 * @param Object
	 * @return void
	 */
	
	
	public void delete(Object obj) throws HibernateException {
		this.getHibernateTemplate().delete(obj);
	}

	/**
	 * 保存对象
	 * @param Object
	 * @return 
	 * 
	 */
	
	public void save(Object obj) throws HibernateException {
		this.getHibernateTemplate().save(obj);
	}
	/**
	 * 保存或更新对象
	 * @param Object
	 * @return
	 * 
	 */

	public void saveOrUpdate(Object obj) throws HibernateException {
		this.getHibernateTemplate().saveOrUpdate(obj);
	}
	
	/**
	 * 更新对象
	 * @param Object
	 * @return void
	 *  
	 * 
	 */

	public void update(Object obj) throws HibernateException {
		this.getHibernateTemplate().update(obj);

	}
	
}

其实在完成userAction的时候，或者在写完不和数据库打交道的业务逻辑后，就可以开始导入Hibernate了。

加载MyEclipse的Hibernate一般可以手动加载，也可以用MyEclipse加载，这里演示MyEclipse加载，可分为两步，

一：配置数据源

、然后直接finish就可以了

二：加载jar包、配置等

其实，最后这里选与不选都可以的。只是会生成一些实例性的hibernate类。

期间可能会报错

然

导入相应的包即可

后就是配置映射了。

剩下的next next （下一步可以选hibernate style）next  next finish（话说没有那么多next的  ~.~ ）

这样，三个框架就基本融合完毕。我们可以看一下细节部分。

applicationContext.xml中多了关于hibernate的一段配置文件

<bean id="bean" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName"
			value="com.mysql.jdbc.Driver">
		</property>
		<property name="url" value="jdbc:mysql://localhost:3306/sms"></property>
		<property name="username" value="root"></property>
		<property name="password" value="123"></property>
	</bean>
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource">
			<ref bean="bean" />
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.MySQLDialect
				</prop>
			</props>
		</property>
</bean>

包浏览视图下面可以看到，多了model和其对应的映射文件。（别忘了hibernate是多种映射方式的，这里只介绍XML映射）

这些都是自动生成的。不用手动写，（当然，要能认得是什么意思，作用。好修改。）

这个时候，就能调用idaoToolService 的接口方法，访问其实现类（继承了HibernateDaoSupport）

public class DaoToolServiceImpl extends HibernateDaoSupport implements
		IDaoToolService {

	/**
	 * 
	 * 查询数据库信息
	 * @param String hql
	 * @return List list
	 */

	public List quesr(String hql) throws HibernateException {
		// TODO Auto-generated method stub
		//cool 酷毙了~~~~~~~~就是HibernateTemplate 了 马老师也是建议用这个的。。。
		return this.getHibernateTemplate().find(hql);
	}

	
	/**
	 * 删除对象
	 * @param Object
	 * @return void
	 */
	
	
	public void delete(Object obj) throws HibernateException {
		this.getHibernateTemplate().delete(obj);
	}

	/**
	 * 保存对象
	 * @param Object
	 * @return 
	 * 
	 */
	
	public void save(Object obj) throws HibernateException {
		this.getHibernateTemplate().save(obj);
	}
	/**
	 * 保存或更新对象
	 * @param Object
	 * @return
	 * 
	 */

	public void saveOrUpdate(Object obj) throws HibernateException {
		this.getHibernateTemplate().saveOrUpdate(obj);
	}
	
	/**
	 * 更新对象
	 * @param Object
	 * @return void
	 *  
	 * 
	 */

	public void update(Object obj) throws HibernateException {
		this.getHibernateTemplate().update(obj);

	}
	
}

public final void setSessionFactory(SessionFactory sessionFactory) {  
      if (this.hibernateTemplate == null || sessionFactory != this.hibernateTemplate.getSessionFactory()) {  
          this.hibernateTemplate = createHibernateTemplate(sessionFactory);  
      }  
} 
public final HibernateTemplate getHibernateTemplate() {  
      return this.hibernateTemplate;  
}  

这时.getHibernateTemplate().update(obj)什么的，都可以用了

框架融合插补多就到这了，

剩下都就是业务逻辑什么的编写了