BlogJava-morcble的blog-文章分类-Spring

spring-framework-1.2.6-chapter11

morcble的blog — Fri, 30 Dec 2005 11:52:00 GMT

11.2. Using the JDBC Core classes to control basic JDBC
processing and error handling

11.2.1.
创建数据源（数据源里隐藏了数据连接池）
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName( "org.hsqldb.jdbcDriver");
dataSource.setUrl( "jdbc:hsqldb:hsql://localhost:");
dataSource.setUsername( "sa");
dataSource.setPassword( "");

11.2.3. SQLExceptionTranslator
配置JdbcTemplate及异常处理
// create a JdbcTemplate and set data source
JdbcTemplate jt = new JdbcTemplate();
jt.setDataSource(dataSource);
// create a custom translator and set the datasource for the default translation lookup
MySQLErrorCodesTransalator tr = new MySQLErrorCodesTransalator();
tr.setDataSource(dataSource);
jt.setExceptionTranslator(tr);
// use the JdbcTemplate for this SqlUpdate
SqlUpdate su = new SqlUpdate();
su.setJdbcTemplate(jt);
su.setSql("update orders set shipping_charge = shipping_charge * 1.05");
su.compile();
su.update();

11.2.4 简单的调用配置好了的JdbcTemplate就可以执行SQL语句如下

import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class ExecuteAStatement {
  private JdbcTemplate jt;
  private DataSource dataSource;
  public void doExecute() {
   jt = new JdbcTemplate(dataSource);
   jt.execute("create table mytable (id integer, name varchar(100))");
  }
  public void setDataSource(DataSource dataSource) {
   this.dataSource = dataSource;
  }
}

11.2.5. 执行查询语句
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class RunAQuery {
   private JdbcTemplate jt;
   private DataSource dataSource;
   public int getCount() {
  jt = new JdbcTemplate(dataSource);
  int count = jt.queryForInt("select count(*) from mytable");
  return count;
}

public String getName() {
   jt = new JdbcTemplate(dataSource);
   String name = (String) jt.queryForObject("select name from mytable", String.class);
   （注：如果更新语句就书写jt.update("update mytable set name = ? where id = ?", new Object[] {name, new Integer(id)});）
   return name;
}①

        public List getList() {
   jt = new JdbcTemplate(dataSource);
   List rows = jt.queryForList("select * from mytable");
   return rows;
}②   （①②取其一）

public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
}

morcble的blog 2005-12-30 19:52 发表评论

spring-framework-1.2.6-chapter8

morcble的blog — Fri, 30 Dec 2005 11:49:00 GMT

8.2. Transaction strategies
1。使用SPRING平台事务管理器

The PlatformTransactionManager definition will look like this:

使用JTA事务管理器
If we use JTA, as in the dataAccessContext-jta.xml file from the same sample application, we need to use a
container DataSource, obtained via JNDI, and a JtaTransactionManager implementation. The
JtaTransactionManager doesn't need to know about the DataSource, or any other specific resources, as it will
use the container's global transaction management.

以上两种方法实现的功能是等效的。

2。把hibernate和spring结合起来




           org/springframework/samples/petclinic/hibernate/petclinic.hbm.xml




           ${hibernate.dialect}



①（局部事务）

①处With Hibernate and JTA transactions we could simply use the JtaTransactionManager as with JDBC or any
other resource strategy.
（JTA为全局事务）

声明式事务管理

...


      PROPAGATION_REQUIRED,-MyCheckedException
      PROPAGATION_REQUIRED
      PROPAGATION_REQUIRED,readOnly

morcble的blog 2005-12-30 19:49 发表评论

spring-framework-1.2.6-chapter3

morcble的blog — Wed, 28 Dec 2005 11:38:00 GMT

最基础的包中有两个是org.springframework.beans 和org.springframework.context .这两个包提供了spring依赖注射功能的基础。
BeanFactory提供了高级的配置机制用于管理beans。
ApplicationContext接口建立在BeanFactory接口之上（BeanFactory的子类），又添加了其它的功能，比如：更容易与Spring AOP功能结合，信息资源处理，事件传播，建立ApplicationContext和父Contexts的机制，应用层特殊的context（如WebApplicationContext）。
ApplicationContext是BeanFactory的扩展，所有BeanFactory的功能都能在ApplicationContext中实现。在建立的项目处于j2ee环境的时候最好选择ApplicationContext；当你对内存的占有很关心的时候（如一个applet会关心每KB大小）可以选择BeanFactory（占内存少）。
BeanFactory 是为了访问Spring bean container，可以把它看成事实上的container.一般简单的BeanFactory的实现是org.springframework.beans.factory.xml.XmlBeanFactory。
创建 BeanFatory的3个办法如下
1。Resource res = new FileSystemResource("beans.xml");
   XmlBeanFactory factory = new XmlBeanFactory(res);
2。ClassPathResource res = new ClassPathResource("beans.xml");
   XmlBeanFactory factory = new XmlBeanFactory(res);
3。ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml", "applicationContext-part2.xml"});
      // of course, an ApplicationContext is just a BeanFactory
   BeanFactory factory = (BeanFactory) appContext;
   （注：public interface Resourceextends InputStreamSource，
        public interface InputStreamSource）
多数用法中，用户不需要编写代码初始化BeanFactory 或 ApplicationContext，因为Spring框架会自动完成。例如：在web层提供了代码自动装载
ApplicationContext，作为正常的j2eeWEB应用程序开始的一部分。

配置bean的XML几种格式如下：
(1)。通过构造函数创建bean，bean可以是javabean 也可以不是，也不用实现别的接口。


    如果你需要实现IOC机制，你的bean需要一个默认的空参数构造函数。
(2)。通过静态工厂函数创建bean.
        factory-method="createInstance"/>
      createInstance是examples.ExampleBean2的静态工厂方法，用于生成exampleBean。
(3).通过实例工厂方法创建bean.

...

To singleton or not to singleton
class="examples.ExampleBean" singleton="false"/>
class="examples.ExampleBeanTwo" singleton="true"/>

几种依赖注射格式
(1)setter注射

1

public class ExampleBean {
private AnotherBean beanOne;
private YetAnotherBean beanTwo;
private int i;

public void setBeanOne(AnotherBean beanOne) {
this.beanOne = beanOne;
}
public void setBeanTwo(YetAnotherBean beanTwo) {
this.beanTwo = beanTwo;
}
public void setIntegerProperty(int i) {
this.i = i;
}
}

(2)构造函数注射

1

public class ExampleBean {
private AnotherBean beanOne;
private YetAnotherBean beanTwo;
private int i;
public ExampleBean(AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {
this.beanOne = anotherBean;
this.beanTwo = yetAnotherBean;
this.i = i;
}
}

(3)静态工厂注射

1

public class ExampleBean {
...
// a private constructor
   private ExampleBean(...) {
   ...
   }
// a static factory method
// the arguments to this method can be considered the dependencies of the bean that
// is returned, regardless of how those arguments are actually used.
     public static ExampleBean createInstance(AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {
        ExampleBean eb = new ExampleBean(...);
       // some other operations
        ...
      return eb;
     }
}

构造函数配置的另一种格式

7500000
42

可以在配置文件中加入验证数据的类型如下

7500000
42

一般属性配置格式

     com.mysql.jdbc.Driver

     jdbc:mysql://localhost:3306/mydb

     root

注意：默认为空字符串，

属性null的格式如下

属性collection的格式如下


     The magic property
     The funny property



     a list element followed by a reference





         yup an entry
         just some string


         yup a ref




     just some string

3.3.3.4. Inner bean definitions via nested bean elements


      //嵌套的bean不需要id
         Tony
         51

复合属性定义

属性fred下有属性bob,bob属性下有sammy 把sammy置为123。

3.3.4. Method Injection（方法注射）



   ...


我的理解：myBean 中必须实现 protected [abstract] SingleShotHelper createSingleShotHelper();
singleShotHelper中必须实现 protected SingleShotHelper createSingleShotHelper();
运行时 singleShotHelper的createSingleShotHelper会覆盖myBean的createSingleShotHelper。//未验证

3.3.4.2. Arbitrary method replacement（任意的方法替换）
public class MyValueCalculator {
     public String computeValue(String input) {
     ... some real code
     }
     ... some other methods
}

进行替换的类必须实现接口org.springframework.beans.factory.support.MethodReplacer
public class ReplacementComputeValue implements MethodReplacer {
   public Object reimplement(Object o, Method m, Object[] args) throws Throwable {
// get the input value, work with it, and return a computed result
   String input = (String) args[0];
   ...
   return ...;
}
}

       String     这里表示方法接受的参数，有几个列几个。
                     这样myValueCalculator中的computeValue方法就被替换了

3.4.1生命周期

public class ExampleBean {
   public void init() {
    // do some initialization work
   }
}
Is exactly the same as:

public class AnotherExampleBean implements InitializingBean {
public void afterPropertiesSet() {
// do some initialization work
}
}

public class ExampleBean {
    public void cleanup() {
   // do some destruction work (like closing connection)
   }
}
Is exactly the same as:

    public class AnotherExampleBean implements DisposableBean {
    public void destroy() {
      // do some destruction work
    }
}

===============================================
3.7. 用BeanPostProcessors自定义beans
   ConfigurableBeanFactory bf = new .....; // create BeanFactory
    ... // now register some beans
   // now register any needed BeanPostProcessors
    MyBeanPostProcessor pp = new MyBeanPostProcessor();
   bf.addBeanPostProcessor(pp);
   // now start using the factory

3.8. 用BeanFactoryPostProcessors 自定义bean factories
   XmlBeanFactory factory = new XmlBeanFactory(new FileSystemResource("beans.xml"));
     // create placeholderconfigurer to bring in some property
     // values from a Properties file
   PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();
   cfg.setLocation(new FileSystemResource("jdbc.properties"));
   // now actually do the replacement
   cfg.postProcessBeanFactory(factory);
（也可以声明式定义




）

由上
以下这个处于beanfactory容器里的数据源就按jdbc.properties里的配置了

其中jdbc.properties如下
jdbc.driverClassName=org.hsqldb.jdbcDriver
jdbc.url=jdbc:hsqldb:hsql://production:9002
jdbc.username=sa
jdbc.password=root

3.8.2. The PropertyOverrideConfigurer

3.19. Creating an ApplicationContext from a web application

contextConfigLocation
/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml

org.springframework.web.context.ContextLoaderListener
（the listener cannot be used in Servlet 2.2 compatible
containers 但是在Servlet2.4后都普遍采用它）

morcble的blog 2005-12-28 19:38 发表评论

spring-framework-1.2.6-chapter1

morcble的blog — Wed, 28 Dec 2005 04:14:00 GMT

spring 由7个模块组成。
1。Core package 是spring框架最基础的包。它提供了依赖注射机制，让你能够通过调用函数管理bean容器。这里最基础的概念是BeanFactory（public interface BeanFactory），它可以通过工厂模式创建singletons，不再需要你自己编程实现；并且可以解耦你的实际程序的业务逻辑。
2。Context package 提供了框架式访问beans的方法，类似JNDI-registry。它继承了Beans包的功能，并添加了支持文本信息的发送的功能，例如：资源捆绑，事件传播，资源装载和透明的上下文创建。具体应用实例如servlet容器。
3。DAO package 提供了一个提取了jdbc的层，让你不必编写乏味的jdbc代码，不必考虑因不同数据库的代码差异而带来的错误。jdbc包（org.springframework.jdbc）提供了一个声明式（在xml配置文件中说明）的事务管理，不仅针对实现特定接口的类有用，而且对所有的POJOs (plain old java objects)。
4。ORM package 针对目前流行的对象关系映射APIS提供了多个综合的层，其中包括了JDO,Hibernate和iBatis.使用这个包你可以把以上3个O/R-mappers结合Spring提供的所有功能，如前面提到的简单声明式的事务管理。
5。AOP package 让你可以定义符合AOP联盟规范的（AOP规范组织）面向面编程的具体实现，如方法拦截和切点，干净的给从逻辑说应该被分离的功能实现代码解耦。使用源码级的元数据功能，你可以把各种行为信息并入你的代码中。
6。Web package 提供了基础的web功能，如multipart功能，使用servlet listeners初始化contexts。引导web的application context。在使用spring和WebWork或者Struts集成的时候需要整合这个包。
7。Web MVC package 提供了针对web程序的MVC实现。它提供了一个清晰的model和web forms的分离，并允许你使用所有其它的spring框架的功能，如有效性验证（用户提交的信息正确与否的验证）。

morcble的blog 2005-12-28 12:14 发表评论