Shulou(Shulou.com)06/02 Report--

How to understand the spring framework, many novices are not very clear about this, in order to help you solve this problem, the following editor will explain for you in detail, people with this need can come to learn, I hope you can gain something.

Spring: layered JavaSE/EE application full-stack lightweight open source framework, with Ioc (inversion control) and AOP (facet programming) as the core, provides numerous enterprise application technologies such as presentation layer springMVC, persistence layer spring JDBC and business layer transaction management, and can integrate many famous third-party frameworks and class libraries in the open source world. It has gradually become the most widely used open source framework for JavaEE enterprise applications.

Advantages:

1. Facilitate decoupling and simplify development

2. Support for AOP programming

3. Support for declarative transactions

4. Convenient program testing

5. It is easy to integrate various excellent frameworks.

6. Reduce the difficulty of using JavaEE

7. Classic learning examples of source code

Program coupling: the dependencies of program keys, including dependencies between classes and methods.

Decoupling: reducing dependencies between programs

It should be done in the actual development, the compilation time does not depend on it, but the runtime does.

The solution is as follows:

Step 1: use reflection to create objects instead of using the new keyword

Step 2: get the fully qualified class name of the object to be created by reading the configuration file.

Ioc:

Concept: inversion of control and handing over the right to create objects to the framework is an important feature of the framework, not an object-oriented term. It includes dependency injection and dependency lookup.

Function: reduce the coupling of computer programs and release the dependencies in our code.

Use:

1. Configure the xml file

2. Get the ioc core container and get the object according to id

ApplicationContext ac = new ClassPathXmlApplicationContext ("Bean.xml"); IAccountDao accountDao = ac.getBean ("accountDao", IAccountDao.class); IAccountService accountService = ac.getBean ("accountService", IAccountService.class)

Three common implementation classes for ApplicationContext:

1. ClassPathXmlApplicationContext: it can load the configuration file under the classpath, which requires that the configuration file must be under the classpath. If it is not there, it cannot be loaded.

2. FileSystemXmlApplicationContext: it can load configuration files under any path to the disk, as long as it has access rights.

3. AnnotationConfigApplicationContext: it is used to read annotations to create containers.

ApplicationContext: when building the core container, the strategy for creating objects is to load them immediately, that is, as soon as you finish reading the configuration file, you will create the configured objects in the configuration file, which is suitable for singleton objects.

BeanFactory: when building the core container, it adopts the strategy of deferred loading to create objects, that is, when to get objects according to id and when to actually create objects, which is suitable for multiple objects.

There are three ways to create a Bean:

First: create using the default constructor

Note: if there is no default constructor in the class, the object cannot be created.

Second: create an object using the method in the normal factory class (use the method in a class to create the object and store it in the spring container)

Third: create objects using static methods in the factory (create objects using static methods in a class and store them in the spring container)

The scope of Bean is adjusted:

Scope attribute of the bean tag

Function: used to specify the scope of bean

Value:

Singleton: singleton, default

Prototype: multiple cases

Request: the scope of requests that apply to web applications

Session: session scope for web applications

Global-session: the session scope that acts on a clustered environment. When it is not a cluster, it is session.

Life cycle of Bean

Singleton object

Birth: when the container is created, the object is born

Alive: as long as the container is there, the object is always alive.

Death: container destroyed, object dead

Multiple object

Birth: when we use objects, create

Alive: the object is always alive as long as it is in use

Death: when the object is not used for a long time and no other object is referenced, the garbage collector of java collects it

Dependency injection for spring:

Function: to maintain dependencies

Data that can be injected:

1. Basic types and String

2. Other bean types (in the configuration file or note the configured bean)

3. Complex type / collection type

Method of injection:

1. Use the constructor to provide

Inside the bean tag, use the tag constructor-arg

Attributes in the tag:

Type: used to specify the data type to be injected, which is also the type of one or some parameters in the constructor

Index: used to specify the data to be injected to assign a value to the parameter at the specified index location in the constructor, starting at 0

Name: used to assign values to parameters with the specified name in the constructor

Value: used to provide data for basic types and string types

Ref: used to specify other bean type data, which refers to bean objects that have appeared in the Ioc core container of spring

Benefit: when getting a bean object, injecting data is a necessary operation, otherwise the object cannot be created successfully

The downside: it changes the way bean objects are instantiated so that when we create objects, we have to provide this data if we don't need it.

2. Use the set method to provide

Inside the bean tag, use property

Attributes of the tag:

Name: used to specify the name of the set method to be called during injection

Value: used to provide data for basic types and String types

Ref: used to specify other bean type data. It refers to the bean object that has appeared in the Ioc container of spring

Benefit: there are no clear restrictions when creating objects, so you can use the default constructor directly

The downside: if a member must have a value, it is possible that the set method did not execute

3. Use annotations to provide

Complex type injection (collection, array, propertise)

1 、 array,list,set

Aaa bbb ccc

Note: just change the corresponding subtag under the property tag to the corresponding type

2 、 map

3 、 properties

Work 1

Common Ioc comments:

Note that when using the annotated configuration, you must first modify the configuration file of xml

1. The function of creating an object is the same as that of the bean tag in xml configuration file

@ Component

Function: store the current class object in the spring container

Attribute: value: the id used to specify bean. When we do not write, the default value is the current class name, with lowercase initials.

@ Controller: generally used in the presentation layer

@ Service: generally used in the business layer

@ Repository: generally used in the persistence layer

The above three annotations have the same function and properties as Conponent, but provide us with clear annotations for the use of the three layers, making our three-tier objects clearer.

2. Used to inject data: the function is the same as the property tag in the xml configuration file

@ Autowired

Function; automatically inject by type, as long as there is only one bean object type in the container that matches the variable type to be injected. If no bean type in the Ioc container matches the variable type to be injected, an error is reported. If more than one type in the Ioc container matches, match the Id name of the corresponding type in the Ioc container according to the variable name.

Occurrence location: either on a variable or on a method

Details: the set method is not required when using annotation injection

@ Qualifier

Function: inject by name on the basis of injection in the class. It cannot be used alone when injecting class members. It must be used in conjunction with Autowired, but it can be used when injecting method parameters.

Attribute: value: used to specify the id into which the bean is injected.

@ Resource

Function: directly follow the id injection of bean, which can be used alone

Attribute: name: id used to specify bean

@ value

Purpose: used to inject data of basic data types and String types

Attribute: value: used to specify the value of the data, which can be used when spEl in spring

SpEl is written in: # {expression}

3. Used to change the scope: the function is the same as that achieved by using the scope attribute in the bean tag

@ Scope

Function: used to specify the scope of bean

Attribute: value: the value of the specified range. Commonly used: singleton (default), prototype

4. Related to the life cycle: the role is the same as the use of init-method and destroy-method in the bean standard

@ PreDestroy

Function: used to specify the destruction method

@ PostConstruct

Function: used to specify the initialization method

Other notes for Ioc:

@ Configuration

Function: the current class is a configuration class

@ ConponentScan

Purpose: use annotations to specify packages to be scanned by spring when creating containers

Attribute: value: it serves the same purpose as basePackages, specifying the package to be scanned when the container is created.

@ Bean

Function: used to store the return value of the current method as a bean object in the ioc container of spring

Attribute: name: id used to specify the Bean. The default value is the name of the current method.

Note: when using annotated configuration methods, if the method has parameters, the spring framework will look in the container to see if any bean objects are available, just like the Autowired mechanism.

Configure the class using annotations:

ApplicationContext ac = new AnnotationConfigApplicationContext (springConfig.class)

@ import

Purpose: used to import other configuration classes

@ propertySource

Purpose: used to specify the location of the properties file

Attribute: value, specify the name and path of the file, classpath, which indicates that under the classpath

Spring integrates Junit

Step 1: import the jar package of spring Integration Junit

Step 2: replace the original main method with the one provided by spring using an annotation provided by Junit

@ Runwith

Step 3: tell the operator of spring whether the ioc creation of spring is based on xml or annotations, and indicate the location

@ ContextConfiguration

Location: specify the location of the xml file, plus the classpath keyword to indicate that under the classpath

Classes: specify the location of the annotation class

Note: when we use spring version 5.X, the jar of Junit must be above 4.12

AOP:

Concept: aspect-oriented programming, which is to extract the repeated code of the perfect program, use dynamic proxy technology when it needs to be executed, and enhance the perfect existing methods without modifying the source code.

Related terms:

Joinpoint: join point: simply a method that can be enhanced

Pointcut: pointcut: simply an enhanced method

Advice: notification: what to do after intercepting joinpoint. Type of notification: pre-notification, post-notification, exception notification, final notification, surround notification.

Introduction: introduction: is a special notification that allows you to dynamically add methods to a class at run time without modifying the code.

Target: target object: proxied object

Weaving: the process of applying enhancements to the target object to create a new proxy object

Proxy: proxy: when a class is enhanced by AOP weaving, a result proxy class is generated.

Aspect: facets: a combination of pointcuts and notifications

Based on XML:

1. Add the section to the Ioc container

2. Use the aop:config tag to indicate the beginning of the configuration of AOP

3. Use the aop:aspect tag to indicate the configuration section

Id: provide a unique identification for the section

Ref: is the id that specifies the notification class bean

4. Use the corresponding tag inside the aop:aspect tag to configure the type of notification

Aop:before: indicates that the configuration advance notification is executed before the pointcut method is executed

Method: specifies which method in the logger class is the advance notification

Pointcut: used to specify a pointcut expression that refers to which methods in the business layer are enhanced

How to write pointcut expression: execution (expression)

Expression: the access modifier returns the value package name. Class name. Method name (parameter list)

The all-pass method of writing *.

The actual development is usually written as follows: * package name.

Aop:after-returning: post notification, executed after pointcut method execution

Aop:after-throwing: exception notification, executed after the pointcut execution generates an exception

Aop:after: final notification that the pointcut method will be executed later, regardless of whether the pointcut method is executed properly or not

Aop:around: wrap configuration. After configuring the orbit notification, you need to pass parameters in the pointcut method, explicitly call the pointcut, and so on.

Based on the annotation method:

@ Component ("logger") @ Aspect//@EnableAspectJAutoProxypublic class Logger {@ Pointcut ("execution (* lianbang.wu.service.Impl.*.* (..)") Private void pt1 () {}; @ Before ("pt1 ()") public void printLog () {System.out.println ("methods in the Logger class start logging.") ;}

Note: ProceedingJoinPoint type parameter must be passed in for surround notification

@ Around ("pt1 ()") public void around (ProceedingJoinPoint joinPoint) {System.out.println ("pre-notification"); try {joinPoint.proceed ();} catch (Throwable throwable) {throwable.printStackTrace ();} System.out.println ("post notification");}

JdbcTemplate

Function: used to interact with database and realize CRUD operation on tables

Public class JdbcTemplateDemo {public static void main (String [] args) {/ / 0, prepare data source DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource (); driverManagerDataSource.setDriverClassName ("com.mysql.jdbc.Driver"); driverManagerDataSource.setUrl ("jdbc:mysql://localhost:3306/eesy"); driverManagerDataSource.setUsername ("root"); driverManagerDataSource.setPassword ("120609") / / 1. Create object JdbcTemplate jdbcTemplate = new JdbcTemplate (); jdbcTemplate.setDataSource (driverManagerDataSource); / / 2. Execute operation jdbcTemplate.execute ("insert into account (id,uid,money) value");}}

Add: you can put the above two new objects into the Ioc object and call the

Is it helpful for you to read the above content? If you want to know more about the relevant knowledge or read more related articles, please follow the industry information channel, thank you for your support.

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.