<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>

<c:redirect url="home.htm"/>
<c:redirect url="b.jsp">
<c:param name="data" value="jsp_passdata中文傳值"></c:param>
</c:redirect>

他们两个作用相似
<jsp:forward page="/utils/errorReporter.jsp"/>

<jsp:forward page="/test4.jsp">
<jsp:param name="name" value="powerman"/>
<jsp:param name="address" value=" 北京西大街188号"/>
</jsp:forward>

<fmt:requestEncoding value="big5"/>

public abstract class HttpServletBean
extends HttpServlet

Simple extension of HttpServlet which treats its config parameters (init-param entries within the servlet tag in web.xml) as bean properties.

HttpServlet的简单扩展用来处理 （init-param）in the web.xml
A handy superclass for any type of servlet. Type conversion of config parameters is automatic, with the corresponding setter method getting invoked with the converted value. It is also possible for subclasses to specify required properties. Parameters without matching bean property setter will simply be ignored.

This servlet leaves request handling to subclasses, inheriting the default behavior of HttpServlet (doGet, doPost, etc).

This generic servlet base class has no dependency on the Spring ApplicationContext concept. Simple servlets usually don't load their own context but rather access service beans from the Spring root application context, accessible via the filter's ServletContext (see WebApplicationContextUtils).

The FrameworkServlet class is a more specific servlet base class which loads its own application context. FrameworkServlet serves as direct base class of Spring's full-fledged DispatcherServlet.

public abstract class FrameworkServlet
extends HttpServletBean
implements ApplicationListener

Base servlet for Spring's web framework. Provides integration with a Spring application context, in a JavaBean-based overall solution.

spring web Framework的基础 servlet  ，提供在以javabean为基础的整体解决方案已完成与spring应用上下文的集成
This class offers the following functionality:
1.管理一个servlet一个网络应用上下文实例，这个servlet的配置由servlet命名空间里的bean来决定
2.根据请求处理发布事件，是否请求成功的被处理了

• Manages a WebApplicationContext instance per servlet. The servlet's configuration is determined by beans in the servlet's namespace.
• Publishes events on request processing, whether or not a request is successfully handled.

Subclasses must implement doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse) to handle requests. Because this extends HttpServletBean rather than HttpServlet directly, bean properties are automatically mapped onto it. Subclasses can override initFrameworkServlet() for custom initialization.

因为它继承自httpservletBean 所以bean的属性已经被自动的装配了，子类可以通过覆盖initFrameworkServlet来定制初始化bean

Detects a "contextClass" parameter at the servlet init-param level, falling back to the default context class, XmlWebApplicationContext, if not found. Note that, with the default FrameworkServlet, a custom context class needs to implement the ConfigurableWebApplicationContext SPI.

Passes a "contextConfigLocation" servlet init-param to the context instance, parsing it into potentially multiple file paths which can be separated by any number of commas and spaces, like "test-servlet.xml, myServlet.xml". If not explicitly specified, the context implementation is supposed to build a default location from the namespace of the servlet.

Note: In case of multiple config locations, later bean definitions will override ones defined in earlier loaded files, at least when using Spring's default ApplicationContext implementation. This can be leveraged to deliberately override certain bean definitions via an extra XML file.

The default namespace is "'servlet-name'-servlet", e.g. "test-servlet" for a servlet-name "test" (leading to a "/WEB-INF/test-servlet.xml" default location with XmlWebApplicationContext). The namespace can also be set explicitly via the "namespace" servlet init-param.

HeidiSQL

				
<bean id="exampleInitBean" class="examples.ExampleBean" init-method="cleanup"/>
				
<bean id="exampleInitBean" class="examples.ExampleBean" destroy-method="cleanup"/>

Bean factory implementations should support the standard bean lifecycle interfaces as far as possible. The full set of initialization methods and their standard order is:
BeanFactory的实现应该尽可能支持标准的bean生命周期，以下是所以的方法的顺序的依次列表
1. BeanNameAware's   setBeanName
2. BeanClassLoaderAware's  setBeanClassLoader
3. BeanFactoryAware's   setBeanFactory
4. ResourceLoaderAware's setResourceLoader (only applicable when running in an application context)
5. ApplicationEventPublisherAware's setApplicationEventPublisher (only applicable when running in an application context)
6. MessageSourceAware's setMessageSource (only applicable when running in an application context)
7. ApplicationContextAware's setApplicationContext (only applicable when running in an application context)
8. ServletContextAware's setServletContext (only applicable when running in a web application context)
9. postProcessBeforeInitialization methods of BeanPostProcessors
10. InitializingBean's afterPropertiesSet
11. a custom init-method definition
12. postProcessAfterInitialization methods of BeanPostProcessors
 当关闭一个bean的时候
On shutdown of a bean factory, the following lifecycle methods apply:
1. DisposableBean's destroy
2. a custom destroy-method definition

Method Summary
boolean	containsBean(String name)           Does this bean factory contain a bean with the given name?
String[]	getAliases(String name)           Return the aliases for the given bean name, if any.
Object	getBean(String name)           Return an instance, which may be shared or independent, of the specified bean.
Object	getBean(String name, Class requiredType)           Return an instance, which may be shared or independent, of the specified bean.
Class	getType(String name)           Determine the type of the bean with the given name.
boolean	isPrototype(String name)           Is this bean a prototype?
boolean	isSingleton(String name)           Is this bean a shared singleton?
boolean	isTypeMatch(String name, Class targetType)           Check whether the bean with the given name matches the specified type.

 

public interface Lifecycle

Interface defining methods for start/stop lifecycle control. The typical use case for this is to control asynchronous processing.

Can be implemented by both components (typically a Spring bean defined in a Spring BeanFactory) and containers (typically a Spring ApplicationContext). Containers will propagate start/stop signals to all components that apply.

Can be used for direct invocations or for management operations via JMX. In the latter case, the MBeanExporter will typically be defined with an InterfaceBasedMBeanInfoAssembler, restricting the visibility of activity-controlled components to the Lifecycle interface.

Since:

2.0

Author:

Juergen Hoeller

See Also:

ConfigurableApplicationContext , AbstractMessageListenerContainer, SchedulerFactoryBean

---

Method Summary
boolean	isRunning ()           Check whether this component is currently running.
void	start ()           Start this component.
void	stop ()           Stop this component.

 

Spring中Bean的生命周期

在传统的Java应用中，Bean的生命周期非常简单。Java的关键词new用来实例化Bean（或许他是非序列化的）。这样就够用了。相反，Bean的生命周期在Spring容器中更加细致。理解Spring Bean的生命周期非常重要，因为你或许要利用Spring提供的机会来订制Bean的创建过程。 1. 容器寻找Bean的定义信息并且将其实例化。 2.受用依赖注入，Spring按照Bean定义信息配置Bean的所有属性。 3.如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的ID。 4.如果Bean实现了BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身。 5.如果BeanPostProcessor和Bean关联，那么它们的postProcessBeforeInitialzation()方法将被调用。 6.如果Bean指定了init-method方法，它将被调用。 7.最后，如果有BeanPsotProcessor和Bean关联，那么它们的postProcessAfterInitialization()方法将被调用。     到这个时候，Bean已经可以被应用系统使用了，并且将被保留在Bean Factory中知道它不再需要。有两种方法可以把它从Bean Factory中删除掉。 1.如果Bean实现了DisposableBean接口，destory()方法被调用。 2.如果指定了订制的销毁方法，就调用这个方法。     Bean在Spring应用上下文的生命周期与在Bean工厂中的生命周期只有一点不同，唯一不同的是，如果Bean实现了ApplicationContextAwre接口，setApplicationContext()方法被调用。

INSTR方法的格式为
INSTR(源字符串, 目标字符串, 起始位置, 匹配序号)

////匹配序号是从左边开始数起，而不管其实位置的正负。
///当起始位置为负数时，从右边数起来计算返回的结果
select  instr(' ',' ',1,1)返回的值为空

例如：INSTR('CORPORATE FLOOR','OR', 3, 2)中，源字符串为'CORPORATE FLOOR', 目标字符串为'OR'，起始位置为3，取第2个匹配项的位置。

默认查找顺序为从左到右。当起始位置为负数的时候，从右边开始查找。

所以SELECT INSTR('CORPORATE FLOOR', 'OR', -1, 1) "Instring" FROM DUAL的显示结果是

Instring
——————
14  ApplicationContext ctx = new ClassPathXmlApplicationContext("knight.xml");

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[%5p] %d{HH:mm:ss} %c{1} - %m%n

log4j.rootLogger=WARN, stdout

log4j.category.com.springinaction=DEBUG
log4j.category.org.springframework=WARN

package com.springinaction.chapter01.knight;

import java.lang.reflect.Method;

import org.apache.log4j.Logger;
import org.springframework.aop.MethodBeforeAdvice;

public class MinstrelAdvice implements MethodBeforeAdvice {
  public void before(Method method, Object[] args, Object target)
      throws Throwable {

    Knight knight = (Knight) target;
   
    Logger song = Logger.getLogger(target.getClass());
   
    song.debug("Brave " + knight.getName() + " did " + method.getName());
  }
}

package com.springinaction.chapter01.knight;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.core.io.FileSystemResource;
public class KnightApp {
  private static final org.apache.log4j.Logger LOGGER = org.apache.log4j.Logger
      .getLogger(KnightApp.class);
 
  public static void main(String[] args) throws Exception {
    LOGGER.debug("Running KnightApp");
    ApplicationContext m;
    BeanFactory factory =
        new XmlBeanFactory(new FileSystemResource("knight.xml"));

///有XmlBeanFactory来负责具体的实现     knight.xml必须要保存在项目的总目录下面
Knight knight =
        (Knight) factory.getBean("knight");

    knight.embarkOnQuest();
    System.out.println("ok");
    LOGGER.debug("KnightApp Finished");
  }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">

///////在spring里所有的bean都是具体的实现，所谓的装配bean就是装配一个具体的实现
<beans>
  <bean id="quest"
      class="com.springinaction.chapter01.knight.HolyGrailQuest"/>
/////转配一个实现类，用来实现一个接口

  <bean id="knightTarget"
      class="com.springinaction.chapter01.knight.KnightOfTheRoundTable">
    <constructor-arg>
      <value>Bedivere</value>
    </constructor-arg>
    <property name="quest">
////这里是装备一个这个类的属性
      <ref bean="quest"/>
    </property>
  </bean>
 
  <bean id="minstrel"
      class="com.springinaction.chapter01.knight.MinstrelAdvice"/>
     
  <bean id="knight"
      class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces">
      <list>
        <value>com.springinaction.chapter01.knight.Knight</value>
      </list>
    </property>
    <property name="interceptorNames">
      <list>
        <value>minstrel</value>
      </list>
    </property>
    <property name="target"><ref bean="knightTarget"/></property>
  </bean>
 
</beans>
在spring 里所有的类都要实现接口与具体实现的分离  iGoHome.java   iGoHomeImp.java  这两个类来具体完成

List cat =sess.createCriteria(Cat.class).add(Restrictions.like("name","F%").addOrder(Order.asc("name")).addOrder(Order.desc("age")).setMaxResult(20).list();

  <id        name="id"        type="java.lang.Integer"        column="ID">
            <generator class="native">        
                <param name="sequence">S_10924_1_BSE_BENEFICIARY</param>
            </generator>
    </id>

JTS Java Transaction Service 是 J2EE 架构的关键元素。它与 JTA Java Transaction API 结合在一起，使我们能够构建对于各种系统和网络故障都非常健壮的分布式应用程序。事务是可靠应用程序的基本构建块 —— 如果没有事务的支持，编写可靠的分布式应用程序将是非常困难的。幸运的是，JTS 执行的大部分工作对于程序员都是透明的；J2EE 容器使事务划分和资源征用对程序员来说几乎是不可见的。这个由三个部分组成的系列文章的第一期讲述了一些基础知识，包括什么是事务，以及事务对于构建可靠的分布式应用程序来说至关重要的原因。

如果您阅读过任何有关 J2EE 的介绍性文章或者书籍，那么就会发现，只有一小部分资料是专门针对 Java Transaction Service（JTS）或 Java Transaction API（JTA）的。这并不是因为 JTS 是 J2EE 中不重要的部分或者可选部分 —— 恰恰相反。JTS 受到的关注之所以会比 EJB 技术少，是因为它为应用程序提供的服务非常透明 —— 很多开发人员甚至没有注意到在他们的应用程序中事务在哪里开始和结束。在某种意义上，JTS 的默默无闻恰恰是它的成功：因为它非常有效地隐藏了事务管理的很多细节，因此，我们没有听说过或者谈论过很多关于它的内容。但是，您可能想了解它在幕后都为您执行什么功能。

毫不夸张地说，没有事务就不能编写可靠的分布式应用程序。事务允许采用某种控制方式修改应用程序的持久性状态，以便使应用程序对于各种各样的系统故障（包括系统崩溃、网络故障、电源故障甚至自然灾害）更加健壮。事务是构建容错、高可靠性以及高可用性应用程序所需的基本构建块之一。

  <Resource
            name="jdbc/PathPlat"
            auth="Container"
            type="javax.sql.DataSource"
            password="f"
            driverClassName="oracle.jdbc.driver.OracleDriver"
            maxIdle="50"
            maxWait="5000"
            username="t"
            url="jdbc:oracle:thin:@192.168.0.1:1521:www"
            removeAbandoned="true"
            removeAbandonedTimeout="60"
            maxActive="100"/>

Context.xml
<?xml version="1.0" encoding="UTF-8"?>
<Context path="/PathCrm" reloadable="true">
  <ResourceLink global="jdbc/PathPlat" name="jdbc/PathPlat" type="javax.sql.DataSource"/>
</Context>
 
<property  name="connection.datasource">java:comp/env/jdbc/PathPlat</property> 

private String dbName ="java:comp/env/jdbc/SavingsAccountDB";

java:comp/env是组件的JNDI上下文的名字（实际上这个上下文也作为一种资源来处理了，资源查找的过程可以是这样：jndictxt = ctxt.lookup(“java:comp/env”)然后用这个jndictxt来查找资源，ref = jndictxt.lookup("jdbc/SavingsAccountDB")。）jdbc/SavingsAccountDB是资源引用的JNDI名（The jdbc/SavingsAccountDB string is the JNDI name for the resource reference，这句话可能意味着资源引用实际上也跟资源一样处理成一种JNDI绑定对象了，但是实际上应该不是这样，因为在部署描述符中它是引用名元素。因为译者也不是高手，所以这里的具体实现细节有待读者自己研究了：）所以JDBC的DataSource对象的JNDI名就存储在java:comp/env/jdbc的上下文子对象中。（组件运行环境的上下文层次需要进一步了解）

5. 在Type列中选择javax.sql.DataSource。前面说过它是数据库连接工厂

set 元素里不能有重复    Connection conn = HibernateUtil.getSession().connection();