Struts & Hibernate & Spring

Framework knows how to do and leave what to do to user with interface programming and dynamic configuration.

What is Struts?

• Struts is a kind of MVC framework for developing web application, which has finished the flow of controller,knowing how to do when request come in,at same time left the what to do to developer.
• Struts has seperated the presentation layer from the business logic layer.
• Struts has a wide rang of JSP HTML tags, support resolution of DOM tags
• Mainly used to build Web Application
  
  

Structs's process sequence for request

• Apache gets request from client
• Transfer/Pass request to Struts framework
• Struts framework selects a ActionServlet if there is a servlet mapping to request
• Struts framework creates a form bean object related to Action and filled with request content
• Struts will invoke the authentication method of FormBean object. Sometime like Smarty and template in PHP
• If failing to authenticate, response to client to input again or redirect to other link
• If the above process goes well, Struts call method execute() of Action
• In execute() method, user code to resolve data or paremeters from FormBean Object and do some business logic.
• Normally, Action call Session EJB to handle with business logic, such as insert, update, add, search some data.
• After logic is finished, Action create or update a FormBean Objects with result for response
• Action returns a Forward object to ActionServlet, and then is transfered to JSP.
• JSP resolve the Formbean Object and generate HTML to respond.
  
  

 

Hibernate(Linq to SQL)

• Get config file ready(hibernate.cfg.xml)
• In config file all DB information are setting, including JDBC Driver, DB user, password.
• SessionFactory create a session to connect to DB using config setting.
• http://docs.jboss.org/hibernate/orm/4.2/quickstart/en-US/html_single/
• Hibernate convert DB's tables and fields to its own class and class's propertis. Select will return a collection of objects
• 对数据库的写操作包括保存、更新和删除，当保存一个POJO持久对象时，触发Hibernate的保存事件监听器进行处理。Hibernate通过映射文件获得对象对应数据库表名以及属性所对应的表中的列名，然后通过反射机制持久化对象（实体对象）的各个属性，最终组织成向数据库插入新对象的SQLinsert语句。调用了session.save()方法后，这个对象会标识成持久化状态存放在session中，对于Hibernate来说它就是一个持久化了的对象，但这个时候Hibernate还不会真正的执行insert语句，当进行session的刷新同部或事务提交时，Hibernate会把session缓存中的所有SQL语句一起执行，对于更新、删除操作也是采用类似的机制。
• 然后，提交事务并事务提交成功后，这些写操作就会被永久地保存进数据库中，所以，使用session对数据库操作还依赖于Hibernate事务的处理。如果设置了二级缓存，那么这些操作会被同步到二级缓存中，Hibernate对数据库最终操作也是依赖于底层JDBC对数据库进行。
• Hibernate如何从数据库中载入对象.
• 当使用session.load()载入对象时，可以设置是否采用延迟加载，如果延迟加载，那么load返回的对象实际是CGLIB或javassist返回的代理类，它的非主键属性都是空的，这对于对象集合属性很有效。Hibernate以此来节约内存，当真正需要读取对象时，Hibernate会先尝试从session缓存中读取，如果session缓存中数据不存在或者是脏数据并且配置了二级缓存，Hibernate尝试从二级缓存中检索数据，否则Hibernate会根据对象类型，主键等信息组织select语句到数据中读取，再把select结果组织成对象返回。
• Hibernate如何进行数据库查询操作Hibernate提供SQLHQLCriteria查询方式。HQL是其中运用最广泛的查询方式。用户使用session.createQuery()方法以一条HQL语句为参数创建Query查询对象后，Hibernate会使用Anltr库把HQL语句解析成JDBC可以识别的SQL语句，如果设置了查询缓存，那么执行Query.list()时，Hibernate会先对查询缓存进行查询，如果查询缓存不存在，再使用select语句查询数据库。

Spring

• Reference to:http://baike.baidu.com/view/23023.htm,  
• http://www.springsource.org/
• http://www.ibm.com/developerworks/web/library/wa-spring1/?S_TACT=105AGX52&S_CMP=cn-a-j
• Spring provides an incredibly powerful and flexible collection of technologies to improve your enterprise Java application development that is used by millions of developers. It is easy to get started by using our free development tool, Spring Tool Suite, or following one of the many tutorials. If you have specific questions then you can ask them in the community forum, look for a solution in our extensive code samples or search the outstanding Spring documentation.

• Spring is an open source framework created to address the complexity of enterprise application development. One of the chief advantages of the Spring framework is its layered architecture, which allows you to be selective about which of its components you use while also providing a cohesive framework for J2EE application development.

  In this first article in my three-part Spring Series, I introduce you to the Spring framework. I start by describing the functionality of the framework in terms of its underlying modules and then discuss two of the most interesting modules, Spring aspect-oriented programming (AOP), and the Inversion of Control (IOC) container. I then use several examples to demonstrate the workings of the IOC container in a typical application use case scenario. The examples will also lay the foundation for an expanded discussion, later in this series, of the how the Spring framework implements AOP constructs through Spring AOP.

• Spring Structure

Each of the modules (or components) that comprise the Spring framework can stand on its own or be implemented jointly with one or more of the others. The functionality of each component is as follows:

• The core container: The core container provides the essential functionality of the Spring framework. A primary component of the core container is the BeanFactory, an implementation of the Factory pattern. The BeanFactory applies the Inversion of Control (IOC) pattern to separate an application's configuration and dependency specification from the actual application code.
• Spring context: The Spring context is a configuration file that provides context information to the Spring framework. The Spring context includes enterprise services such as JNDI, EJB, e-mail, internalization, validation, and scheduling functionality.
• Spring AOP: The Spring AOP module integrates aspect-oriented programming functionality directly into the Spring framework, through its configuration management feature. As a result you can easily AOP-enable any object managed by the Spring framework. The Spring AOP module provides transaction management services for objects in any Spring-based application. With Spring AOP you can incorporate declarative transaction management into your applications without relying on EJB components.
• Spring DAO: The Spring JDBC DAO abstraction layer offers a meaningful exception hierarchy for managing the exception handling and error messages thrown by different database vendors. The exception hierarchy simplifies error handling and greatly reduces the amount of exception code you need to write, such as opening and closing connections. Spring DAO's JDBC-oriented exceptions comply to its generic DAO exception hierarchy.
• Spring ORM: The Spring framework plugs into several ORM frameworks to provide its Object Relational tool, including JDO, Hibernate, and iBatis SQL Maps. All of these comply to Spring's generic transaction and DAO exception hierarchies.
• Spring Web module: The Web context module builds on top of the application context module, providing contexts for Web-based applications. As a result, the Spring framework supports integration with Jakarta Struts. The Web module also eases the tasks of handling multi-part requests and binding request parameters to domain objects.
• Spring MVC framework: The Model-View-Controller (MVC) framework is a full-featured MVC implementation for building Web applications. The MVC framework is highly configurable via strategy interfaces and accommodates numerous view technologies including JSP, Velocity, Tiles, iText, and POI.

Spring framework functionality can be used in any J2EE server and most of it also is adaptable to non-managed environments. A central focus of Spring is to allow for reusable business and data-access objects that are not tied to specific J2EE services. Such objects can be reused across J2EE environments (Web or EJB), standalone applications, test environments, and so on, without any hassle.

Focus on:Interface-Oriented Programming & Inversion Of Control ( all concreate class is defined in spring application context.xml with object's property).

Take one example to understand how the spring application works.

Step1: We define our interfaces which the application will use. we will interface-oriented programming.

public interface CreateCreditCardAccountInterface 
{
    public CreditLinkingInterface getCreditLinkingInterface();
    public void setCreditLinkingInterface(CreditLinkingInterface creditLinkingInterface);
    public CreditRatingInterface getCreditRatingInterface();
    public void setCreditRatingInterface(CreditRatingInterface creditRatingInterface);
    public EmailInterface getEmailInterface();
    public void setEmailInterface(EmailInterface emailInterface);
    public void createCreditCardAccount(ICustomer icustomer) throws Exception;
}

In CreateCreditCardAccountInterface, we use Interface CreditLinkingInterface

public interface CreditLinkingInterface 
{    
    public String getUrl();    
    public void setUrl(String url);    
    public void linkCreditBankAccount(ICustomer icustomer) throws Exception ;
}

In CreditLinkingInterface, we use interface ICustomer and CreditRatingInterface

//Interface holds customer information.
public interface ICustomer {
    public String getCustomerId();
    public void setCustomerId(String customerId);
    public String getFirstName();
    public void setFirstName(String firstName);
    public IAddress getIAddress();
    public void setIAddress(IAddress address);
    public String getLastName();
    public void setLastName(String lastName);
    public String getSsnId();
    public void setSsnId(String ssnId);    
    public String getEmailAddress();
    public void setEmailAddress(String emailAddress);    
    public boolean isCreditRating() ;
    public void setCreditRating(boolean creditRating);
}

public interface CreditRatingInterface 
{
   public boolean getUserCreditHistoryInformation(ICustomer iCustomer);
}

In ICustomer interface, we use interface  and IAddress

public interface IAddress 
{    
    public String getAddress1() ;    
    public void setAddress1(String address1) ;    
    public String getAddress2();    
    public void setAddress2(String address2);    
    public String getCity() ;    
    public void setCity(String city);    
    public String getCountry() ;    
    public void setCountry(String country);    
    public String getState();    
    public void setState(String state) ;    
    public String getZipCode() ;    
    public void setZipCode(String zipCode) ;    
}

Step2: Now we shall config our application bean with our bussiness logic, these bean will create some concreate objects by Spring using Java Reflection.

?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>    
    <bean id="createCreditCard" class="springexample.creditcardaccount.CreateCreditCardAccount">
        <property name="creditRatingInterface">
            <ref bean="creditRating" />
        </property>
        <property name="creditLinkingInterface">
            <ref bean="creditLinking" />
        </property>
        <property name="emailInterface">
            <ref bean="email" />
        </property>
    </bean>    
    <bean id="creditLinking" class="springexample.creditlinking.CreditLinking">
        <property name="url">
           <value>http://localhost/creditLinkService</value>
        </property>
    </bean>    
    <bean id="creditRating" class="springexample.creditrating.CreditRating">
        </bean>    
    <bean id="email" class="springexample.email.Email">
        <property name="smtpHost">
            <value>localhost</value>
        </property>
        <property name="fromEmail">
            <value>mycompanyadmin@mycompanyadmin.com</value>
        </property>
        <property name="userId">
            <value>myuserid</value>
        </property>
        <property name="password">
            <value>mypassword</value>
        </property>
    </bean>        
</beans>

Step3:OK, all is done, Application can run

• We have main() function as application's entry

package springexample.client;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import springexample.creditcardaccount.CreateCreditCardAccountInterface;
import springexample.domain.Customer;
import springexample.domain.ICustomer;
public class CreateCreditAccountClient 
{    
    public static void main(String[] args)
        {
      try
      {
        System.out.println("CreateCreditAccountClient started"); 
            ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(new String[] {"springexample-creditaccount.xml"});    
        System.out.println("Classpath loaded");    
        ICustomer icustomer = new Customer();
        icustomer.setCustomerId("1A2B3C");
        icustomer.setEmailAddress("xxx@xx.com");
        icustomer.setFirstName("xxx");
        icustomer.setFirstName("yyy");
    
        CreateCreditCardAccountInterface creditCardAccount = (CreateCreditCardAccountInterface)
        appContext.getBean("createCreditCard");    
        creditCardAccount.createCreditCardAccount(icustomer);    
        System.out.println("CreateCreditAccountClient end");
     }
     catch(Exception e)
         {
        e.printStackTrace();
     }
     }
}

• In main function, we have concreate object Customer, now we need a concreate of CreateCreditCardAccountInterface which is given by object of ClassPathXmlApplicationContext via reading applicationcontext.xml
• By reading applicationContext.xml, we acturally have a concreate object of CreateCreditCardAccountInterface like following code:

•     CreateCreditCardAccountInterface creditCardAccount = (CreateCreditCardAccountInterface)
      
      appContext.getBean("createCreditCard"); //This line code acturally can be converted to following code.
      
      //email = Class.forName("springexample.email.Email");
      //emial.setSmtpHost("localhost");
      //emial.setFromEmail("mycompanyadmin@mycompanyadmin.com");
      //emial.setPassword("myuserid");
      //emial.setUserId("mypassword");
      
      //creditRating = Class.forName("springexample.creditrating.CreditRating");
      //creditLinking = Class.forName("springexample.creditlinking.CreditLinking");
      //creditLinking.setUrl("http://localhost/creditLinkService");    
              
      //creditCardAccount = Class.forName("springexample.creditcardaccount.CreateCreditCardAccount");
      //creditCardAccount.setCreditLinkingInterface(creditLinking);
      //creditCardAccount.setCreditRatingInterface(creditLinking);
      //creditCardAccount.setEmailInterface(creditLinking);    
      
      creditCardAccount.createCreditCardAccount(icustomer);

• Till now,all concreate objects is created and application can run correctly.
• Spring' XML: 
  • bean <===> concreate object;
  • <bean id=> define the name of concreate name;
  • <property name="creditRatingInterface"> is mapped to set method "setCreditRatingInterface" with parameter <ref bean="creditLinking" />  where ref means a reference object created as bean. Same as setter and getter methods in C#
  • <value>localhost</value> where value means in-built type with value.