Shulou(Shulou.com)05/31 Report--

This article mainly shows you "what are the common problems in Spring", which is easy to understand and well organized. I hope it can help you solve your doubts. Let the editor lead you to study and learn the article "what are the common problems in Spring".

What is the Spring framework?

Spring is a lightweight development framework designed to improve the efficiency of developers and the maintainability of the system. Spring official website: https://spring.io/.

Generally speaking, Spring framework refers to Spring Framework, it is a collection of many modules, using these modules can easily assist us in development. These modules are: core containers, data access / integration, Web, AOP (aspect-oriented programming), tools, messages, and test modules. For example, Core component in Core Container is the core of all Spring components, Beans component and Context component are the foundation of IOC and dependency injection, and AOP component is used to realize aspect-oriented programming.

There are six features of Spring listed on Spring's official website:

Core technologies: dependency injection (DI), AOP, event (events), resources, i18n, validation, data binding, type conversion, SpEL.

Testing: mock object, TestContext framework, Spring MVC test, WebTestClient.

Data access: transactions, DAO support, JDBC,ORM, marshalling XML.

Web support: Spring MVC and Spring WebFlux Web frameworks.

Integration: remoting, JMS,JCA,JMX, email, tasks, scheduling, caching.

Language: Kotlin,Groovy, dynamic language.

List some important Spring modules?

The following figure corresponds to the Spring4.x version. The Portlet component of the Web module has been obsolete in the latest 5.x version, while the WebFlux component for asynchronous responsive processing has been added.

Spring main module

Spring Core: basic, it can be said that all other functions of Spring depend on this class library. It mainly provides IoC dependency injection function.

Spring Aspects: this module provides support for integration with AspectJ.

Spring AOP: provides aspect-oriented programming implementation.

Spring JDBC: Java database connection.

Spring JMS: Java message service.

Spring ORM: used to support ORM tools such as Hibernate.

Spring Web: provides support for creating Web applications.

Spring Test: provides support for JUnit and TestNG testing.

@ RestController vs @ ControllerController returns a page

Using @ Controller alone without adding @ ResponseBody is generally used in cases where you want to return a view, which is a more traditional Spring MVC application, which corresponds to the situation where the front and rear ends are not separated.

SpringMVC traditional workflow

@ RestController returns data in JSON or XML form

However, @ RestController only returns the object, and the object data is directly written to the HTTP response (Response) in the form of JSON or XML, which belongs to the RESTful Web service, which is the most common situation that daily development comes into contact with (front and rear separation).

SpringMVC+RestController

@ Controller + @ ResponseBody returns data in JSON or XML form

If you need to develop RESTful Web services before Spring4, you need to use @ Controller with @ ResponseBody annotations, that is, @ Controller + @ ResponseBody= @ RestController (a new note after Spring4).

The purpose of the @ ResponseBody annotation is to convert the object returned by the Controller method to the specified format through an appropriate converter, and then write it to the body of the HTTP response (Response) object. It is usually used to return JSON or XML data, and there are many cases in which JSON data is returned.

Spring3.xMVC RESTfulWeb Services Workflow

Reference:

Https://dzone.com/articles/spring-framework-restcontroller-vs-controller (picture source)

Https://javarevisited.blogspot.com/2017/08/difference-between-restcontroller-and-controller-annotations-spring-mvc-rest.html?m=1

Talk about your understanding of Spring IoC and AOP IoC

IoC (Inverse of Control: inversion of Control) is a design idea that transfers the control of objects originally created manually in the program to the Spring framework. IoC is also used in other languages and is not specific to Spirng. IoC container is the carrier that Spring uses to implement IoC. IoC container is actually a Map (key,value), and various objects are stored in Map.

The interdependencies between objects are managed by the IoC container, and the object injection is completed by the IoC container. This can greatly simplify the development of applications and liberate applications from complex dependencies. The IoC container is like a factory. When we need to create an object, we only need to configure the configuration file / annotations, regardless of how the object is created. In a real project, a Service class may have hundreds or even thousands of classes as its underlying class. If we need to instantiate the Service, you may have to figure out the constructors of all the underlying classes of the Service every time, which may drive people crazy. If you use IoC, you just need to configure it and reference it where you need it, which greatly increases the maintainability of the project and reduces the difficulty of development.

In the era of Spring, we usually configure Bean through XML files, but later developers felt that the configuration of XML files was not very good, so the configuration of SpringBoot annotations gradually became popular.

Recommended reading: https://www.zhihu.com/question/23277575/answer/169698662

Initialization process of Spring IoC:

Initialization process of Spring IoC

IoC source code reading

Https://javadoop.com/post/spring-ioc

AOP

AOP (Aspect-Oriented Programming: aspect-oriented programming) can encapsulate the logic or responsibilities (such as transaction processing, log management, access control, etc.) that have nothing to do with business but are jointly invoked by business modules, so as to reduce the repetitive code of the system, reduce the coupling between modules, and is conducive to future scalability and maintainability.

Spring AOP is based on dynamic proxy. If the object to be proxied implements an interface, Spring AOP will use JDK Proxy to create a proxy object. For objects that do not implement the interface, JDK Proxy cannot be used for proxy. In this case, Spring AOP will use Cglib. In this case, Spring AOP will use Cglib to generate a subclass of the proxied object as a proxy, as shown in the following figure:

SpringAOPProcess

Of course, you can also use AspectJ, Spring AOP has integrated AspectJ, AspectJ should be regarded as the most complete AOP framework in the Java ecosystem.

After using AOP, we can abstract some common functions and use them directly where they are needed, which greatly simplifies the amount of code. It is also convenient when we need to add new features, which also improves the scalability of the system. AOP is used in logging functions, transaction management, and so on.

What's the difference between Spring AOP and AspectJ AOP?

Spring AOP is a run-time enhancement, while AspectJ is a compile-time enhancement. Spring AOP is based on Proxying, while AspectJ is based on bytecode operation (Bytecode Manipulation).

Spring AOP has integrated AspectJ, and AspectJ should be the most complete AOP framework in the Java ecosystem. AspectJ is more powerful than Spring AOP, but Spring AOP is relatively simple

If we have fewer sections, there is little difference in performance between the two. However, when there are too many aspects, it is best to choose AspectJ, which is much faster than Spring AOP.

What is the scope of bean in Spring?

Singleton: the only bean instance. Bean in Spring is a singleton by default.

Prototype: a new bean instance is created for each request.

Request: each HTTP request generates a new bean, which is valid only within the current HTTP request.

Session: each HTTP request generates a new bean, which is valid only within the current HTTP session.

Global-session: global session scope, which only makes sense in portlet-based web applications, Spring5 is no longer available. Portlet is a small Java Web plug-in that can generate fragments of semantic code (for example: HTML). They are based on portlet containers and can handle HTTP requests like servlet. However, unlike servlet, each portlet has a different session

Do you understand the thread safety issues of singleton bean in Spring?

Most of the time we don't use multithreading in the system, so few people pay attention to this problem. There is a thread problem in singleton bean, mainly because when multiple threads operate on the same object, there is a thread safety problem in writing to the object's non-static member variables.

There are two common solutions:

It is impractical to try to avoid defining variable member variables in Bean objects.

Define a ThreadLocal member variable in the class and store the required variable member variables in ThreadLocal (a recommended way).

Bean Lifecycle in Spring?

There are a lot of articles about this part online, the following content is sorted out from: https://yemengying.com/2016/07/14/spring-bean-life-cycle/, in addition to this article, I recommend a very good article: https://www.cnblogs.com/zrtqsk/p/3735273.html.

The Bean container finds the definition of Spring Bean in the configuration file.

The Bean container leverages Java Reflection API to create an instance of Bean.

If some attribute values are involved, use the set () method to set some attribute values.

If Bean implements the BeanNameAware interface, call the setBeanName () method, passing in the name of Bean.

If Bean implements the BeanClassLoaderAware interface, call the setBeanClassLoader () method, passing in an instance of the ClassLoader object.

If Bean implements the BeanFactoryAware interface, call the setBeanClassLoader () method, passing in an instance of the ClassLoader object.

Similar to the above, if other * .Aware interfaces are implemented, the corresponding methods are called.

If there is a BeanPostProcessor object associated with the Spring container that loads this Bean, execute the postProcessBeforeInitialization () method

If Bean implements the InitializingBean interface, execute the afterPropertiesSet () method.

If the definition of Bean in the configuration file contains the init-method property, the specified method is executed.

If there is a BeanPostProcessor object associated with the Spring container that loads this Bean, execute the postProcessAfterInitialization () method

When you want to destroy the Bean, execute the destroy () method if the Bean implements the DisposableBean interface.

When the Bean is to be destroyed, the specified method is executed if the definition of the Bean in the configuration file contains the destroy-method attribute.

The figure shows:

Spring Bean lifecycle

Tell me what you know about Spring MVC?

When it comes to this issue, we have to mention the previous era of Model1 and Model2, which had no Spring MVC.

Model1 era: many friends who are late in learning Java backend may not have come into contact with JavaWeb application development in Model1 mode. In Model1 mode, the whole Web application is composed of almost all JSP pages, and only a small amount of JavaBean is used to deal with database connection, access and other operations. In this mode, JSP is both the control layer and the presentation layer. Obviously, there are many problems with this model. For example, ① mixes control logic with presentation logic, resulting in extremely low code reuse; ② front-end and back-end are interdependent, difficult to test and extremely inefficient

Model2 era: friends who have studied Servlet and done related Demo should understand the development mode of "Java Bean (Model) + JSP (View,) + Servlet (Controller)", which is the early JavaWeb MVC development model. Model: the data involved in the system, that is, dao and bean. View: display the data in the model, just for presentation. Controller: all user requests are sent, data is returned to JSP and displayed to the user.

There are still many problems in Model2 mode, and the degree of abstraction and encapsulation of Model2 is far from enough. When developing with Model2, wheels will inevitably be built repeatedly, which greatly reduces the maintainability and reusability of the program. So many MVC frameworks related to JavaWeb development should be shipped, such as Struts2, but Struts2 is bulky. With the popularity of Spring lightweight development framework, Spring MVC framework has appeared in Spring ecosystem. Spring MVC is the best MVC framework at present. Compared with Struts2, Spring MVC is simpler and easier to use, more efficient to develop, and Spring MVC runs faster.

MVC is a design pattern, and Spring MVC is an excellent MVC framework. Spring MVC can help us develop a cleaner Web layer, and it is inherently integrated with the Spring framework. Under Spring MVC, we generally divide the back-end projects into Service layer (processing business), Dao layer (database operation), Entity layer (entity class), and Controller layer (control layer, which returns data to the foreground page).

The simple schematic diagram of Spring MVC is as follows:

Do you understand how SpringMVC works?

The principle is shown in the following figure:

Operation principle of SpringMVC

A small problem with a pen error in the image above: the entry function of the Spring MVC, that is, the front-end controller DispatcherServlet, is to receive the request and respond to the result.

Process description (important):

The client (browser) sends a request directly to the DispatcherServlet.

DispatcherServlet calls HandlerMapping according to the request information to parse the corresponding Handler of the request.

After parsing to the corresponding Handler (also known as the Controller controller), it is processed by the HandlerAdapter adapter.

HandlerAdapter invokes the real processor to process the request based on the Handler and handles the corresponding business logic.

After the processor has finished processing the business, it returns a ModelAndView object, Model is the returned data object, and View is a logical View.

ViewResolver looks for the actual View based on the logical View.

DispaterServlet passes the returned Model to View (view rendering).

Return the View to the requestor (browser)

What design patterns are used in the Spring framework?

For a detailed introduction of some of the design patterns below, you can see the author's original article "interviewer:" what design patterns are used in Spring? " ".

Factory design pattern: Spring uses factory mode to create bean objects through BeanFactory and ApplicationContext.

Agent design pattern: the realization of Spring AOP function.

Singleton design pattern: Bean in Spring is singleton by default.

Template method pattern: jdbcTemplate, hibernateTemplate and other classes in Spring that operate on the database ending with Template, they use the template pattern.

Wrapper design pattern: our project needs to connect to multiple databases, and different customers will access different databases as needed during each visit. This mode allows us to dynamically switch different data sources according to the needs of our customers.

Observer pattern: the Spring event-driven model is a classic application of the Observer pattern.

Adapter pattern: the enhancement or Advice of Spring AOP uses the adapter pattern, and the adapter pattern adaptation Controller is also used in spring MVC.

……

What's the difference between @ Component and @ Bean?

The object is different: the @ Component annotation acts on the class, while the @ Bean annotation acts on the method.

@ Component is usually automatically detected and assembled into the Spring container through classpath scanning (we can use the @ ComponentScan annotation to define the path to be scanned to find out that the classes that need to be assembled are automatically assembled into the bean container of Spring). The @ Bean annotation is usually what we define in the method marked with the annotation. The bean,@Bean tells Spring that this is an example of a class, and give it back to me when I need it.

@ Bean annotations are more customized than Component annotations, and in many places we can only register bean through @ Bean annotations. For example, when we reference a class from a third-party library that needs to be assembled into a Spring container, it can only be done through @ Bean.

Examples of @ Bean annotations:

@ Configurationpublic class AppConfig {@ Bean public TransferService transferService () {return new TransferServiceImpl ();}}

The above code is equivalent to the following xml configuration

The following example cannot be achieved through @ Component.

@ Beanpublic OneService getService (status) {case (status) {when 1: return new serviceImpl1 (); when 2: return new serviceImpl2 (); when 3: return new serviceImpl3 ();}} what are the comments for a bean that declares a class as Spring?

We generally use @ Autowired annotation to automatically assemble bean. To identify a class as a bean class that can be used for automatic assembly of @ Autowired annotation, you can use the following annotation:

Component: a general annotation that can label any class as a Spring component. If a Bean doesn't know which layer it belongs to, you can annotate it with @ Component.

@ Repository: the corresponding persistence layer, namely Dao layer, is mainly used for database-related operations.

@ Service: corresponds to the service layer, which mainly involves some complex logic and needs to use the Dao layer.

Controller: corresponding to the Spring MVC control layer, the main user accepts the user's request and calls the Service layer to return the data to the front-end page.

How many ways does Spring manage transactions?

Programmatic transactions, hard-coded in the code. (not recommended)

Declarative transactions, configured in the configuration file (recommended)

There are two types of declarative transactions:

Declarative transaction based on XML

Annotation-based declarative transaction

What are the isolation levels in Spring transactions?

Five constants representing the isolation level are defined in the TransactionDefinition interface:

TransactionDefinition.ISOLATION_DEFAULT: use the default isolation level of the backend database, the default REPEATABLE_READ isolation level of Mysql, the default READ_COMMITTED isolation level of Oracle.

TransactionDefinition.ISOLATION_READ_UNCOMMITTED: the lowest isolation level that allows uncommitted data changes to be read, which may result in dirty, phantom, or unrepeatable reads

TransactionDefinition.ISOLATION_READ_COMMITTED: allows reading of committed data from concurrent transactions, prevents dirty reads, but phantom or unrepeatable reads can still occur

TransactionDefinition.ISOLATION_REPEATABLE_READ: the result of multiple reads to the same field is consistent, unless the data is modified by its own transaction, which can prevent dirty reading and unrepeatable reading, but phantom reading can still occur.

TransactionDefinition.ISOLATION_SERIALIZABLE: the highest isolation level, fully compliant with the isolation level of ACID. All transactions are executed one by one, so that interference between transactions is completely impossible, that is, this level prevents dirty reading, unrepeatable reading, and phantom reading. But this will seriously affect the performance of the program. This level is not usually used.

What are the transaction propagation behaviors in Spring transactions?

Support for the current transaction:

TransactionDefinition.PROPAGATION_REQUIRED: if there is a transaction, join it; if there is no transaction, create a new transaction.

TransactionDefinition.PROPAGATION_SUPPORTS: if there is a transaction, join it; if there is no transaction, continue to run in a non-transactional manner.

TransactionDefinition.PROPAGATION_MANDATORY: if there is a transaction, join it; if there is no transaction, throw an exception. (mandatory: mandatory)

The current transaction is not supported:

TransactionDefinition.PROPAGATION_REQUIRES_NEW: creates a new transaction and suspends the current transaction if it exists.

TransactionDefinition.PROPAGATION_NOT_SUPPORTED: runs in a non-transactional manner, suspending the current transaction if there is a current transaction.

TransactionDefinition.PROPAGATION_NEVER: runs in a non-transactional manner, throwing an exception if a transaction currently exists.

Other circumstances:

TransactionDefinition.PROPAGATION_NESTED: if there is a transaction, a transaction is created to run as a nested transaction of the current transaction; if there is no transaction, this value is equivalent to TransactionDefinition.PROPAGATION_REQUIRED.

Do you understand the @ Transactional (rollbackFor = Exception.class) annotation?

We know that Exception is divided into runtime exception RuntimeException and non-runtime exception. Transaction management is very important for enterprise applications, even if there are anomalies, it can also ensure the consistency of data.

When the @ Transactional annotation acts on a class, all public methods of that class will have transactional properties of that type, and we can also use this annotation at the method level to override the class-level definition. If this comment is added to the class or method, the method in the class throws an exception and the data in the database is rolled back.

If the rollbackFor attribute is not configured in the @ Transactional annotation, things will only be rolled back when RuntimeException is encountered, and rollbackFor=Exception.class allows things to roll back when they encounter non-runtime exceptions.

How do I use JPA to unpersist a field in a database?

Suppose we have one of the following classes:

Entity (name= "USER") public class User {@ Id @ GeneratedValue (strategy = GenerationType.AUTO) @ Column (name= "ID") private Long id; @ Column (name= "USER_NAME") private String userName; @ Column (name= "PASSWORD") private String password; private String secrect;}

What if we want the secrect field not to be persisted, that is, not stored in the database? We can use the following methods:

Static String transient1; / / not persistent because of staticfinal String transient2 = "Satish"; / / not persistent because of finaltransient String transient3; / / not persistent because of transient@TransientString transient4; / / not persistent because of @ Transient

Generally use the latter two ways more, I personally use more annotations.

The above is all the content of the article "what are the Spring FAQs?" Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.