How does Hibernate work and why?
Principle:
Read and parse the configuration file, read and parse the ing information, create SessionFactory, open Sesssion, create transaction Transation, commit transaction, close Session, close SesstionFactory
Why:
The code for JDBC database access is encapsulated, which greatly simplifies the tedious and repetitive code at the data access layer.
Hibernate is a mainstream persistence framework based on JDBC and an excellent ORM implementation. He greatly simplifies the coding of the DAO layer.
Hibernate uses the Java reflection mechanism instead of bytecode enhancement programs for transparency.
Hibernate has excellent performance because it is a lightweight framework. The flexibility of ing is excellent. It supports various relational databases, from one-to-one to many-to-many complex relationships.
2. How does Hibernate delay loading?
1. Implementation of Hibernate delayed loading: a) object B) Collection)
2. Hibernate provides the property delayed Loading Function
When Hibernate queries data, the data does not exist in the memory. When the program actually operates on the data, the object exists in the memory, and the loading is delayed, it saves the server memory overhead and improves the server performance.
3. How does one implement the relationship between classes in Hibernate? (For example, one-to-many and many-to-many relationships)
The relationship between classes is mainly reflected in the relationship between tables. They operate on objects in a city. In our program, all tables and classes are mapped together, they are used in the configuration file named "allow-to-one", "one-to-allow", "allow-to-allow,
4. Talk about the cache mechanism of Hibernate
1. The internal cache exists in Hibernate, which is also called a level-1 cache, which belongs to the application thing-level cache.
2. Secondary cache:
A) Application and Cache
B) distributed cache
Condition: the data is not modified by a third party, the data size is within the acceptable range, the data update frequency is low, the same data is frequently used by the system, non-critical data
C) third-party cache implementation
5. Hibernate query method
SQL, Criteria, object comptosition
Hql:
Attribute query parameter query and name parameter query associated query paging query statistics function
6. How to optimize Hibernate?
Use bidirectional one-to-Multiple Association instead of unidirectional one-to-multiple flexible use of unidirectional one-to-Multiple Association instead of one-to-one. Use multiple-to-one to replace the configuration object cache, do not use the set cache inheritance class to use less explicit multi-state table fields, do not be afraid of more table associations, there are two levels of cache support
Why:
{AOP allows developers to create non-behavioral concerns, known as cross-cutting concerns, and insert them into application code. With AOP, public services (such as logs, persistence, and transactions) can be decomposed into aspects and applied to domain objects without increasing the complexity of the Object Model of domain objects.
IOC allows you to create an application environment that can construct objects and then pass their collaboration objects to these objects. As the word inversion indicates, IOC is like the reversed JNDI. Instead of using a bunch of abstract factories, service locators, singleton, and straight construction, each object is constructed with its collaborative object. Therefore, collaborator is managed by containers ).
Even an AOP framework, Spring is also an IOC container. The best thing about Spring is that it helps you replace objects. With Spring, you only need to add dependencies (collaboration objects) with the JavaBean attribute and configuration file ). Then, you can easily replace the collaboration object with similar interfaces as needed .}
The Spring framework is a layered architecture consisting of seven well-defined modules. The Spring module is built on the core container. The core container defines how to create, configure, and manage beans, as shown in figure 1.
Each module (or component) that makes up the Spring framework can exist independently or be implemented together with one or more modules. The functions of each module are as follows:
☆Core container: the Core container provides the basic functions of the Spring framework. The main component of the core container is BeanFactory, which is the implementation of the factory mode. BeanFactory uses the control reversal (IOC) mode to separate application configuration and dependency specifications from actual application code.
☆Spring context: Spring context is a configuration file that provides context information to the Spring framework. Spring context includes enterprise services, such as JNDI, EJB, email, internationalization, checksum and scheduling.
☆Spring AOP: Through the configuration management feature, the Spring AOP module directly integrates Aspect-oriented programming functions into the Spring framework. Therefore, any objects managed by the Spring framework can easily support AOP. The Spring AOP module provides transaction management services for objects in Spring-based applications. By using Spring AOP, You can integrate declarative transaction management into applications without relying on EJB components.
☆Spring DAO: The jdbc dao abstraction layer provides a meaningful exception hierarchy for managing Exception Handling and error messages thrown by different database vendors. The exception hierarchy simplifies error handling and greatly reduces the number of Exception Code to be written (for example, opening and closing connections ). JDBC-oriented exceptions of Spring DAO follow the common DAO exception hierarchy.
☆Spring ORM: The Spring framework inserts several ORM frameworks to provide ORM Object Relational tools, including JDO, Hibernate, and iBatis SQL Map. All of these comply with the general transactions and DAO exception hierarchies of Spring.
☆Spring Web module: The Web context module is built on the application context module and provides context for Web-based applications. Therefore, the Spring framework supports integration with Jakarta Struts. The Web module also simplifies processing multiple requests and Binding Request Parameters to domain objects.
☆Spring MVC framework: the MVC Framework is a full-featured MVC implementation for Building Web applications. Through the policy interface, the MVC framework becomes highly configurable. MVC supports a large number of view technologies, including JSP, Velocity, Tiles, iText, and POI.
The functions of the Spring framework can be used on any J2EE server. Most of the functions are also applicable to unmanaged environments. Spring supports reusable services and data access objects that are not bound to a specific J2EE service. There is no doubt that such objects can be reused between different J2EE environments (Web or EJB), independent applications, and test environments.
IOC and AOP
The basic concept of the inversion mode (also known as dependency intervention) is to describe how to create objects without creating them. The Code does not directly connect to objects and services, but describes which component needs which service in the configuration file. Containers (IOC containers in the Spring framework) are responsible for connecting these together.
In a typical IOC scenario, the container creates all objects and sets the necessary properties to connect them together to determine the time to call the method. The following table lists an implementation mode of IOC.
The IOC container of the Spring framework is implemented by Type 2 and Type 3.
Aspect-Oriented Programming
Aspect-oriented programming (AOP) is a programming technology that allows programmers to modularize the behavior of cross-concern or cross-common division of duties (such as log and transaction management. The core structure of AOP is aspect, which encapsulates the behaviors that affect multiple classes into reusable modules.
AOP and IOC are complementary technologies that use modular methods to solve complex problems in enterprise application development. In a typical object-oriented development method, you may need to place the logging statement in all methods and Java classes to implement the logging function. In the AOP mode, the log service can be modularized in turn and applied to the components that require logs in declarative mode. Of course, the advantage is that the Java class does not need to know the existence of the log service or consider the relevant code. Therefore, application code written with Spring AOP is loosely coupled.
The functions of AOP are fully integrated into the context of Spring transaction management, logs, and other features.
IOC container
The core of Spring design is the org. springframework. beans package, which is designed to be used with the JavaBean Component. This package is usually not directly used by users, but is used by the server as the underlying intermediary for most other functions. The next highest level abstraction is the BeanFactory interface, which is an implementation of the factory design pattern and allows the creation and retrieval of objects by name. BeanFactory can also manage relationships between objects.
BeanFactory supports two object models.
□The single-State model provides shared instances for objects with specific names, which can be searched during query. Singleton is the default and most commonly used object model. It is ideal for stateless service objects.
□The prototype model ensures that a separate object is created for each retrieval. When each user needs their own objects, the prototype model is the most suitable.
The concept of bean Factory is that Spring serves as the basis of IOC containers. IOC transfers the responsibility for handling tasks from application code to the framework. As I will demonstrate in the next example, the Spring framework uses the JavaBean attribute and configuration data to indicate the dependencies that must be set.
BeanFactory Interface
Because org. springframework. beans. factory. BeanFactory is a simple interface, it can be implemented for various underlying storage methods. The most common BeanFactory definition is XmlBeanFactory, which loads beans according to the definition in the XML file, as shown in Listing 1.
Listing 1. XmlBeanFactory
BeanFactory factory = new XMLBeanFactory (new FileInputSteam ("mybean. xml "));
The Bean defined in the XML file is passively loaded, which means that the bean itself will not be initialized before the bean is needed. To retrieve beans from BeanFactory, you only need to call the getBean () method and input the name of the bean to be retrieved, as shown in Listing 2.
Listing 2. getBean ()
MyBean mybean = (MyBean) factory. getBean ("mybean ");
The definition of each bean can be POJO (defined by class name and JavaBean initialization attribute) or FactoryBean. The FactoryBean interface adds an indirect level to applications built using the Spring framework.
