关于如何搭建SSH框架，学习后自己的java描述

2.自己手动搭建SSh框架
   1.导入一些个需要的架包然后buildpath引入架包。
   
   2.（Hibernate  domain层）首先建议package  建议持久层包domain，然后新建一个持久层javabean，新建ElecText.hbm.xml文件，
            这个文件的主要作用是用来映射数据库使得数据库中的字段什么的变为对象，接着 配置一下hibernate.cfg.xml文件。
     

<session-factory>
     <property name="hibernate.connection.username">root</property>
     <property name="hibernate.connection.password">123</property>
     <property name="hibernate.connection.autocommit">true</property>
     <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
     <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/itcast1222elec</property>
     <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
     <property name="hibernate.show_sql">true</property>
     <property name="hibernate.hbm2ddl.auto">update</property>
     <property name="hibernate.format_sql">true</property>
    
     <mapping resource="cn/itcast/elec/domain/ElecText.hbm.xml"/>
    </session-factory>

3.（junit测试）新建junit package 里面用来存放一些个测试用的类，首先测试下数据库的连接是否成功所以新建TestHibernate类，
            操作数据库需要sessionFactory所以首先需要读取配置信息，然后创建sessionFactory，之后再opensession，
            要操作数据必须需要事务，session.beginTranscation，new对象然后set一些属性值，session.save（），提交事务，关闭session。
            
   4.（DAO层搭建）持久层完成搭建后，就到了DAO层（数据访问对象），面向接口的编程，这里需要interface和impl，所以新建package impl
             然后分为通用的一些接口，里面放一些大家都需要的方法比如保存，删除。。。 首先创建ICommonDao以及他的实现类ICommonDaoImpl,
      IElecTextDao以及其实现类IElecTextDaoImpl，其中这4个的关系是：具体接口继承通用接口，具体实现继承通用实现并且实现具体接口，
      public void save(T entity);这里使用到了泛型，因为我们这里的对象时ElecText，所以在ICommonDao以及ICommonDaoImpl中
             我们均使用泛型T代表需要传进来的具体对象，这样就很方便了，而在这里IElecTextDao extends ICommonDao<ElecText>传入ElecText
             具体对象，因为我们需要在ICommonDaoImpl实现具体的通用方法并且需要对DB进行操作，这里我们就用到了Spring中的hibernate模板 需要
      extends HibernateDaoSupport，这里 就需要对spring的配置文件beans.xml文件进行配置先具体配置如下：
          
  ------------------------------------------------------------------------------------------------------------         
  

<!-- 1.配置注解自动扫描的范围 -->
  
  <context:component-scan base-package="cn.itcast.elec"></context:component-scan>
  
  <!-- 2.配置数据源 --c3po>
  
  <!-- 3.创建sessionFactory -->
  
  <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
       <property name="configLocation">
         <value>
           classpath:hibernate.cfg.xml
         </value>
       </property>
  </bean>
  
  <!-- 4.创建事物管理器 -->
  
  <bean id="txManage" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
     <property name="sessionFactory" ref="sessionFactory"></property>
  </bean>
  
  <!-- 5.以注解的形式管理事务 -->
  
  <tx:annotation-driven transaction-manager="txManage"/>

  （Ioc 依赖注入2种方式进行注入一种是通过setter方式注入，另一种是通过构造器注入，spring实际就是一个最大的工厂，他是通过
  xml文件来管理java代码的，我们尽量的少用注解的方式来注入，原因是因为spring的出现本来就是为了解决层与层直接的耦合问题，使用注解的
     方式进行注入的话就造成了java代码耦合，所以更推荐使用xml文件来管理bean）
 
 关于4种注解的解释：            
     @Repository、@Service、@Controller 和 @Component 将类标识为Bean。
     @Repository（放结点的服务对象是哪个类，哪个服务对象提供服务的）它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。
           具体只需将该注解标注在 DAO类上即可（可以定义一个常量放在实现类的接口里面，这样可以采用注入的形式通过spring得到DAO层实现的对象）
     @Component 是一个泛化的概念，仅仅表示一个组件 (Bean) ，可以作用在任何层次。
     @Service 通常作用在业务层，但是目前该功能与 @Component 相同。
     @Constroller 通常作用在控制层，但是目前该功能与 @Component 相同。
   
           如此，我们就不再需要在 XML 中显式使用 <bean/> 进行Bean 的配置。
     Spring 在容器初始化时将自动扫描 base-package 指定的包及其子包下的所有 class文件
           所有标注了 @Repository 的类都将被注册为 Spring Bean。      
           通过在类上使用 @Repository、@Component、@Service 和 @Constroller 注解，
     Spring会自动创建相应的 BeanDefinition 对象，并注册到 ApplicationContext 中。
           这些类就成了 Spring受管组件。
  --------------------------------------------------------------------------------------------------------         
     上述的步骤完成以后我们就需要在ICommonDaoImpl中执行save（）方法，但是此时需要操作DB所以就必须要有sessionFactory
     那么如何注入呢？2种方式一种是通过在xml文件中注入，另一种是通过注解的形式注入@resource。
     
 

public class ICommonDaoImpl<T> extends HibernateDaoSupport implements ICommonDao<T>  
     /**
*  <bean id="xxxxx" class="cn.itcast.elec.dao.impl.CommonDaoImpl">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
我们是通过注解的方式创建sessionFactory
*/
@Resource(name="sessionFactory")
public final void setSessionFactory1(SessionFactory sessionFactory){
super.setSessionFactory(sessionFactory);
} 

//有了sessionFactory就可以 创建hibernate模板，就可以执行一系列操作，代码如下：   
public void save(T entity) {
this.getHibernateTemplate().save(entity);
}  

下面到了这个类的编写：
    public class ElecTextDaoImpl extends ICommonDaoImpl<ElecText> implements IElecTextDao     
    ElecTextDaoImpl他继承了ICommonDaoImpl<ElecText>所以泛型里面就是ElecText类型的对象了，也继承了他的
    save（）方法；不用new而是使用：
    @Repository(IElecTextDao.SERVICE_NAME)//放在实现类中
    //放在接口中是因为面向接口编程
    public final static String SERVICE_NAME="cn.itcast.elec.dao.impl.ElecTextDaoImpl";
    SERVICE_NAME这个常量是提供服务的对象spring注入就不需要new了
最后编写测试类TestDao：
        首先加载上下文内容加载beans.xml文件，然后获取beans
    IElecTextDao elecTextDao = (IElecTextDao)ServiceProvider.getService(IElecTextDao.SERVICE_NAME);
    ServiceProvider这个方法的出现是因为我们测试的时候总是需要写一些重复的加载代码是的程序的运行速度很慢，
         所以我们就自定义了一个容器，用来封装。
         然后实例化对象ElecText elecText=new ElecText();
               elecText.setTextName("呵呵");
      elecText.setTextDate(new Date());
      elecText.setTextRemark("没什么事情！");
      elecTextDao.save(elecText);//保存测试就Ok了。
      
   5.(Service层的搭建)Dao层搭建完毕以后就考虑service层的搭建 ，通过spring的解耦方式，我们可以很轻松的让service层
     dao层分离。service层也是采用面向接口的编程，创建接口IElecTextService，然后创建实现类ElecTextServiceImpl
           它实现了上面接口，然后需要注入让spring管理，所以我们采用@service方式注入因为需要面向接口，所以放在接口里面      
     public final static String SERVICE_NAME="cn.itcast.elec.service.impl.ElecTextServiceImpl";
           接口中建立一个save（）方法，并在实现类中实现，这里需要实现save（）方法就必须和Dao联系，所以我们使用注解的形式就不
           需要new了，采用@Service（name=“IElecTextDao.SERVICE_NAME”);
                 private IElecTextDao elecTextDao;
                 public void saveElecText(ElecText elecText){
              elecTextDao.save(elecText);
            }
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
最后新建一个TestService测试类。ok没问题。下面就出现一个问题就是：在业务逻辑层我们有增删改会操作DB查询不用操作DB
然后就是操作DB就需要事务提交去处理一些操作，事务就不能默认他自己去提交，我们就需要控制一下，所以我们这样将类级别的事务
定义为只读，@Transactional(readOnly=true)，但是此时运行就会出错，因为增删改都需要write而类上面是只读，所以我们
可以将一些增删改的方法定义为：@Transactional(isolation=Isolation.DEFAULT, propagation=Propagation.REQUIRED,readOnly=false)
                                                                                    隔离级别                                                   广播通知形式
         以上方法说明了方法级别的事务覆盖了类级别的事务！
         
   6.（Controller层的搭建）现在我们开始搭建控制层，这里我们使用的Struts2技术来搭建，这里我们首先需要准备的java类是：VO JavaBean也就是
            前台表单的值 ，ElecTextAction类,Struts2.xml也就是他的配置文件，web.xml文件也需要关注。下面说一些VO和PO的区别：
            ①VO对象指的是表单的属性值，PO对象对应的是持久层的和数据库对应的字段。（同时需要将css，js，。。页面导入）
            ②他们都是JavaBean最大的区别就是Vo对象属性可以随意的改动，而Po对象是不能随意的改动的，因为他对应的是DB。
      
      
    public class ElecTextAction extends ActionSupport implements ModelDriven<ElecTextForm>{
//所谓ModelDriven，意思是直接把实体类当成页面数据的收集对象;
//利用ModelDriven机制，让UserAction实现一个ModelDriven接口，同时实现接口中的方法：getModel();
//该方法返回一个用于接收用户输入数据的对象模型，在这个模型对象中的属性可以直接通过(属性名)userName来访问，
//而不需要使用（对象名.属 性名）user.userName这种格式来访问了，在action也不需要对对象提供getter和setter方法了，
//但是必须要在action中进 行new操作, ModelDriven<ElecTextForm>一定要使用泛型。

private ElecTextForm elecTextForm =new ElecTextForm();
public ElecTextForm getModel() {
return elecTextForm;
}

public String save(){
//System.out.println(elecTextForm.getTextName());
//vo对象转化为po对象因为执行保存的时候是在操作数据库所以使用po对象保存，在页面上显示的时候用的是vo对象
//实例化po对象
//vo和po类型不一样所以用一个util类转换
ElecText elecText =new ElecText();
elecText.setTextName(elecTextForm.getTextName());
elecText.setTextDate(StringHelper.stringConvertDate(elecTextForm.getTextDate()));
elecText.setTextRemark(elecTextForm.getTextRemark());

return "save";

}


   }
   StringHelper.stringConvertDate(elecTextForm.getTextDate())这里需要用到类型转换，所以我们封装一个
       将  String类型转化为Date类型的工具类，创建Util package 。
   public class StringHelper {
//将字符串形式转化为日期形式
public static Date stringConvertDate(String date){
   SimpleDateFormat simpleDateFormat =new SimpleDateFormat("yyyy-MM-dd");
   Date d =null;
try {
d=simpleDateFormat.parse(date);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

return d;
}

下面是配置struts2的配置文件：

<!-- 配置action的访问路径为.do的形式 -->
<constant name="struts.action.extension" value="do"></constant>
<!-- 配置struts的开发模式 -->
<constant name="struts.devMode" value="true"></constant>
<!-- 配置struts的简单模式 -->
<constant name="struts.ui.theme" value="simple"></constant>
<package name="system"  extends="struts-default">
<action name="elecTextAction_*" class="cn.itcast.elec.web.action.ElecTextAction" method="{1}">
<result name="save">
/system/textAdd.jsp
</result>
</action>
</package>

然后需要对Controller层进行测试，那么需要用到业务层，我们采用spring的形式将业务层注入进来
ApplicationContext  ac  = new  ClassPathXmlApplicationContext（“beans.xml”）；
ac.getBean(......);
如果每次都需要加载这2句话，那么程序的运行效率就会特别低，所以可以自定义一个容器，将这2句话封装起来
就可以使每次只要加载一次就可以了，提高了程序的效率。

至此项目的框架搭建完毕。。