spring2总结(30-40)

于 2010-05-12 20:23:00 发布
阅读量118 收藏
点赞数
分类专栏： spring2.0 文章标签： spring bean class exception action prototype
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/pingfanwuzhe/article/details/5584010
版权

 

       userManager.login(laf.getUsername(), laf.getPassword());

      

       return mapping.findForward("success");

    }

 

    public void setUserManager(UserManager userManager) {

       this.userManager = userManager;

    }

 

补充说明：

3、在struts-config.xml文件中配置Action

    * <action>标签中的type属性需要修改为org.springframework.web.struts.DelegatingActionProxy

     DelegatingActionProxy是一个Action，主要作用是取得BeanFactory，然后根据<action>中的path属性值

     到IoC容器中取得本次请求对应的Action

     

4、在spring配置文件中需要定义struts的Action,如：

    <bean name="/login" class="com.bjsxt.usermgr.actions.LoginAction" scope="prototype">

       <property name="userManager" ref="userManager"/>

    </bean>

    * 必须使用name属性，name属性值必须和struts-config.xml文件中<action>标签的path属性值一致

    * 必须注入业务逻辑对象

    * 建议将scope设置为prototype,这样就避免了struts Action的线程安全问题

   

 

十八、spring+struts+hibernate集成

 

Mysql的hibernate的配置

 

<session-factory>

       <property name="hibernate.connection.url">jdbc:mysql://localhost/spring_struts_hibernate</property>

       <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

       <property name="hibernate.connection.username">root</property>

       <property name="hibernate.connection.password">bjsxt</property>

       <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

       <property name="hibernate.show_sql">true</property>

       <!-- 当创建sessionFactory时候就把hbm导入成ddl表了 -->

       <property name="hibernate.hbm2ddl.auto">update</property>

    </session-factory>

 

在web.xml文件中解决字符集的问题

 

  <filter>

    <filter-name>Spring character encoding filter</filter-name>

    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

    <init-param>

    <param-name>encoding</param-name>

    <param-value>GBK</param-value>

    </init-param>

  </filter>

 

  <filter-mapping>

    <filter-name>Spring character encoding filter</filter-name>

    <url-pattern>/*</url-pattern>

  </filter-mapping>

 

解决lazy的问题

 

<filter>

    <filter-name>hibernateFilter</filter-name>

<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>

  </filter>

 <filter-mapping>

    <filter-name>hibernateFilter</filter-name>

    <url-pattern>/*</url-pattern>

  </filter-mapping>

 

 

 

二十、HibernateDaosupport的使用数据的操作

1、

保存

public void addItem(Item item) {

              try {

//保存

                     this.getHibernateTemplate().save(item);

              }catch(Exception e) {

                     e.printStackTrace();

//往上抛异常

                     throw new Exception（e）;

              }

在dao里面异常往上抛 直接用this.getHibernateTemplate().save(item);就可以了】

 

更新

this.getHibernateTemplate().update(item);

 

删除

for (int i=0; i<itemNoList.length; i++) {

                            Item item = (Item)this.getHibernateTemplate().load(Item.class, itemNoList[i]);

                            this.getHibernateTemplate().delete(item);

                     }

 

Id查询

item = (Item)this.getHibernateTemplate().load(Item.class, itemNo);

 

/**

     * 根据条件查询物料信息

     * @param queryStr 查询条件

     * @return item对象的集合

     */

       public PageModel findAllItem(final int pageNo, final int pageSize, final String queryStr) {

              PageModel pageModel = null;

              List itemList = new ArrayList();

              try {

                     if (queryStr != null && queryStr.trim().length() != 0) {

                            itemList = this.getHibernateTemplate().executeFind(new HibernateCallback() {

 

                                   public Object doInHibernate(Session session)

                                                 throws HibernateException, SQLException {

                                          return session.createQuery("from Item a where a.itemNo like ? or a.itemName like ? order by a.itemNo")

                                                                      .setParameter(0, queryStr + "%")

                                                                      .setParameter(1, queryStr + "%")

                                                                      .setFirstResult((pageNo - 1) * pageSize)

                                                                      .setMaxResults(pageSize)

                                                                      .list();

                                   }

                            });

                     }else {

                            itemList = this.getHibernateTemplate().executeFind(new HibernateCallback() {

 

 

                                   public Object doInHibernate(Session session)

                                                 throws HibernateException, SQLException {

                                          return session.createQuery("select a from Item a join fetch a.category b join fetch a.unit c order by a.itemNo")

                                          .setFirstResult((pageNo - 1) * pageSize)

                                          .setMaxResults(pageSize)

                                          .list();

                                   }

                            });

                     }

                    

                     pageModel = new PageModel();

                     pageModel.setPageNo(pageNo);

                     pageModel.setPageSize(pageSize);

                     pageModel.setList(itemList);

                     pageModel.setTotalRecords(getTotalRecords(queryStr));

              }catch(Exception e) {

                     //记录日志,log4j等......

                     e.printStackTrace();

                     throw new AppException("drp.database.item.error.findallitem");

              }    

              return pageModel;

 

3、

//经常用模板来封装横切性的问题和模板性的代码

 

Sql在模板中的使用

 

private int getTotalRecords(String queryStr) {

              Long totalRecords = 0L;

              if (queryStr != null && queryStr.trim().length() != 0) {

                     //采用模板取得总记录数据

                     totalRecords = (Long)this.getHibernateTemplate().find("select count(*) from Item a where a.itemNo like ? or a.itemName like ?",

                                                                              new Object[]{queryStr + "%", queryStr + "%"}).get(0);

              }else {

                     //采用session取得总记录数

                     totalRecords = (Long)this.getSession().createQuery("select count(*) from Item a").uniqueResult();

              }

              return totalRecords.intValue();

       }

4、在静态方法当中调用

 

public class Functions {

   

    private static SessionFactory sessionFactory;

   

    /**

     * 返回物料类别的结合

     * @return ItemCategory对象的集合

     */

    public static List getItemCategoryList() {

       List itemCategoryList = null;

       try {

           HibernateTemplate ht = new HibernateTemplate(sessionFactory);

           return ht.find("from ItemCategory a order by a.id");

       }catch(Exception e) {

           //记录日志,log4j等......

           e.printStackTrace();

       }

       return itemCategoryList;

    }

 

    /**

     * 返回物料类别的结合

     * @return ItemCategory对象的集合

     */

    public static List getItemUnitList() {

       List itemUnitList = null;

       try {

           HibernateTemplate ht = new HibernateTemplate(sessionFactory);

           return ht.find("from ItemUnit a order by a.id");

       }catch(Exception e) {

           //记录日志,log4j等......

           e.printStackTrace();

       }

       return itemUnitList;

    }

 

    public void setSessionFactory(SessionFactory sessionFactory) {

       Functions.sessionFactory = sessionFactory;

    }

}

 

 

上传路径注入

 

       private String uploadPath;

public void setUploadPath(String uploadPath) {

              this.uploadPath = uploadPath;

       }

 

FileOutputStream fos = new FileOutputStream(this.uploadPath + iaf.getItemNo() + ".gif");

                     fos.write(myFile.getFileData());

                     fos.flush();

                     fos.close();

 

上传路径注入方式

 

<bean name="/basedata/item" class="com.bjsxt.drp.web.itemmgr.actions.ItemAction">

    <property name="itemManager" ref="itemManager"/>

    <property name="uploadPath">

        <value>C://apache-tomcat-5.5.26//webapps//ssh_training_itemmgr//images//item//</value>

    </property>

</bean>

 

 

Spring2.5正在 完善--------简影如下-----------

 

Spring2.5总结

向先函 2009-11-23

 

所谓的IOC控制翻转：应用本身不负责依赖对象的创建及维护，依赖对象的创建和维护是由外部容器负责的。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓的反 转。

 

所谓的依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到组建中。

 

轻量级或重量级：

主要看它使用了多少服务，使用的服务越多，容器要为普通java对象做的工作就越多，必然会影响到应用的发布时间或运行性能，对于spring容器，它提供了很多服务，但这些服务并不是默认为应用打开的，应用需要某种服务，还需要指明使用该服务，如果应用使用的服务很少，如果只使用了spring核心服务，那么我们可以认为此时应用属于轻量级的，如果应用使用了spring提供的大部分服务，这时应用就属于重量级。目前EJB容器就是因为他默认为应用提供了EJB规范中的所有功能，所以它属于重量级。

 

 

一、spring jar包

 

 

配置bean.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.5.xsd">

          <bean id="personService" class="cn.Gxcme.service.impl.PersonServiceBean"></bean>

</beans>

 

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">//存在于网络用于提示，如果提示找不到，在xml下的xmlcatelog添加spring-beans-2.5.xsd文件，选择Schema location，最后在key 的位置增加文件的后最

 

<bean id="personService"//ID受到XML解析器的验证，不允许有特殊字符，而name 允许有特殊字符、

 

实例化spring容器常用的两种方式

方法一、

在路径下寻找配置文件来实例化容器

ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"beans.xml"});

 

方法二、

在文件系统路径下寻找配置文件来实例化容器

ApplicationContext ctx = new FileSystemXmlApplicationContext(new String[]{“d://beans.xm”});

Sping的配置文件可以指定多个，可以通过String数字传入

 

获取bean的名称并引用

PersonService personService = (PersonService)ctx.getBean("personService");

       personService.save();

 

 

 

 

三种实例化bean的方式

 

1.       使用类构造器实例化

配置文件

<bean id = “orderService”  class =”cn.Gxcme.orderServiceBean”/>

类中使用

PersonService personService = (PersonService)ctx.getBean("personService");

       personService.save();

 

 

2.       使用静态工厂方法实例化

<bean id = “orderService”  class =”cn.Gxcme.orderServiceBean” fanctory-method = “createOrder’/>

类中配置

Public class OrderFactory{

         Public static OrderServiceBean createOrder(){

Return new OrderServiceBean();

}

}

 

3.       使用实例工厂方法实例化

 

<bean id = “personServiceFactory”  class =”cn.Gxcme.service.OrderFactory” />

<bean id = “personService”  factory-bean =” personServiceFactory” factory-method = “createOrder” />

类中配置

Public class OrderFactory{

         Public  OrderServiceBean createOrder(){

Return new OrderServiceBean();

}

}

 

统一使用：

ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

       PersonService personService = (PersonService)ctx.getBean("personService3");

       personService.save();

 

 

bean的作用域

 

默认singleton，在bean节点的lazy-init=”true”来延迟初始化，这时候只有第一次获取bean会才初始化bean。

如<bean id="personService" class="cn.Gxcme.service.impl.PersonServiceBean" lazy-init = "true"/>

如果：<beans default-lazy-init = “true”>则对所有bean都进行延迟初始化

.prototype 每次从容器获取bean都是新的对象

 

使用：

<bean id="personService" class="cn.Gxcme.service.impl.PersonServiceBean" scope="prototype"/>

 

Web中的作用域

.request

Session

Global session

 

Singleton单例 ,在容器实例化时实例化

 

Prototype原型 ，在getBean的时候才实例化的

 

更改lazy-init = "true"可以改变其初始化方式

 

初始化和销毁实例里边的方法的方法：

<bean id="personService" class="cn.Gxcme.service.impl.PersonServiceBean" lazy-init="false"

          init-method="init" destroy-method="destory">

 

要正常关闭spring容器：更改使用的方法

AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

       //PersonService personService1 = (PersonService)ctx.getBean("personService");

       ctx.close();

 

 

通过对接口注入的方式：set注入

 

Dao：

package cn.Gxcme.dao;

 

public interface PersonDao {

 

    public void add();

 

}

 

实现类：

import cn.Gxcme.dao.PersonDao;

 

public class PersonDaoBean implements PersonDao {

    public void add(){

       System.out.println("执行PersonDaoBean中的add()方法");

    }

}

 

调用类：

 

 

public class PersonServiceBean implements PersonService {

    private PersonDao personDao;

 

    public void setPersonDao(PersonDao personDao) {

       this.personDao = personDao;

    }

   

    public void save(){

       personDao.add();

    }

}

 

配置xml

<bean id="personDao" class="cn.Gxcme.dao.impl.PersonDaoBean"></bean>

          <bean id="personService" class="cn.Gxcme.service.impl.PersonServiceBean">

             <property name="personDao" ref="personDao"></property>//通过反射机制拿到

          </bean>

 

使用：

 

GxcmeClassPathXMLApplicationContext ctx = new GxcmeClassPathXMLApplicationContext("beans.xml");

       PersonService personService =

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值