spring5.14参考文档

2019-02-05 本文已影响0人 luckee

spring mvc
request-->DispatcherServlet-->MappingHandler-->AdaptorHandler-->Handler-->ModelAndView（String逻辑视图，void直接response、sendRedict、forward）-->view-->response
IOC控制反转
对象的声明周期交给spring容器来管理，xml配置<bean id/name="" class/type="" scope="" lazy-init="true">，也可以通过注解的方式向spring容器注册bean；也可以通过代码注册（通过context获得DefaultListableBeanFactory接口类型的对象，调用registerSingleton和registerBeanDefinition方法注册）

注解	描述
@Component	没有明确的角色分工
@Repository	dao，dao层
@Service	service，service层
@Controller	action，表现层

使用注解的时候可以指定bean的id，如@Repository("userDao")，如果不指定，默认为把类名的首字母改为小写后的字符串作为bean的id

DI依赖注入
可以使用XML配置文件的方式（分为基于getter/setter方法和构造函数两种配置方式），也可以使用注解的方式。

注解	描述
@Autowired(require=true/false)	Autowired按类型进行自动装配，配合@Qualifier使用，@Qualifier("beanid")
@Inject	是JSR-330提供的注解
@Resource(name="beanname")	是JSR-250提供的注解

AOP面向切面编程

以动态代理为基础

其他注解

注解	描述
@RequestBody	request数据使用json形式
@ResponseBody	json形式返回
@RequestMapping	url映射
@RequestParam	参数绑定

spring核心组件

Bean，Context，Core

Bean，即bean，是IOC容器中的bean
Context，应用上下文，是IOC容器，是容器中各个bean之间的关系的集合
Core，一些核心类，Resource表示资源，是通用的，屏蔽了不同类型的资源的差异。Resource 接口继承了 InputStreamSource 接口，这个接口中有个 getInputStream 方法，返回的是 InputStream 类，这样所有的资源都被可以通过 InputStream 这个类来获取，所以也屏蔽了资源的提供者。另外还有一个问题就是加载资源的问题，也就是资源的加载者要统一，这个任务是由 ResourceLoader 接口完成，它屏蔽了所有的资源加载者的差异，只需要实现这个接口就可以加载所有的资源，它的默认实现是 DefaultResourceLoader。
BeanFactory接口；ApplicationContext接口就是IOC容器，它继承了BeanFactory接口。ApplicationContext有好几个实现，常见的有ClassPathXmlApplicationContext和FileSystemXmlApplicationContext和WebApplicationContext，配置的方式有多种，xml-based，annotation-based，java-based
一般在IOC容器中注册dao，service，action，基础设施如SessionFactory等，domain的bean一般不注册，非IOC容器创建的bean也可以通过IOC来管理

Typically, you define service layer objects, data access objects (DAOs), presentation objects such as Struts Action instances, infrastructure objects such as Hibernate SessionFactories, JMS Queues, and so forth. Typically, one does not configure fine-grained domain objects in the container, because it is usually the responsibility of DAOs and business logic to create and load domain objects. However, you can use Spring’s integration with AspectJ to configure objects that have been created outside the control of an IoC container.

IOC（xml注册（单个或包扫描），注解注册，DefaultListableBeanFactory代码注册）

Naming

<bean id="myBean" name="mybean" class/type="com.example.MyBean" scope="prototype" lazy-init="true" init-method="" destroy-method="">

Alias

<alias name="fromName" alias="toName"/>

Instantiate

默认构造器

<bean id="exampleBean" class="examples.ExampleBean"/>

静态工厂方法

<bean id="clientService"
    class="examples.ClientService"
    factory-method="createInstance"/>

对应的java代码

public class ClientService {
    private static ClientService clientService = new ClientService();
    private ClientService() {}

    public static ClientService createInstance() {
        return clientService;
    }
}

实例工厂方法

<!-- the factory bean, which contains a method called createInstance() -->
<bean id="serviceLocator" class="examples.DefaultServiceLocator">
    <!-- inject any dependencies required by this locator bean -->
</bean>

<!-- the bean to be created via the factory bean -->
<bean id="clientService"
    factory-bean="serviceLocator"
    factory-method="createClientServiceInstance"/>

<bean id="accountService"
    factory-bean="serviceLocator"
    factory-method="createAccountServiceInstance"/>

对应java代码

public class DefaultServiceLocator {

    private static ClientService clientService = new ClientServiceImpl();
    private static AccountService accountService = new AccountServiceImpl();

    public ClientService createClientServiceInstance() {
        return clientService;
    }

    public AccountService createAccountServiceInstance() {
        return accountService;
    }
}

DI（xml配置，注解）

IOC容器通过构造器或者工厂方法创建了bean后，对bean进行依赖注入

constructor-based

构造器参数是引用类型

package x.y;

public class ThingOne {

    public ThingOne(ThingTwo thingTwo, ThingThree thingThree) {
        // ...
    }
}

<beans>
    <bean id="beanOne" class="x.y.ThingOne">
        <constructor-arg ref="beanTwo"/>
        <constructor-arg ref="beanThree"/>
    </bean>

    <bean id="beanTwo" class="x.y.ThingTwo"/>

    <bean id="beanThree" class="x.y.ThingThree"/>
</beans>

构造器函数式简单类型

ackage examples;

public class ExampleBean {

    // Number of years to calculate the Ultimate Answer
    private int years;

    // The Answer to Life, the Universe, and Everything
    private String ultimateAnswer;

    public ExampleBean(int years, String ultimateAnswer) {
        this.years = years;
        this.ultimateAnswer = ultimateAnswer;
    }
}

①使用type

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg type="int" value="7500000"/>
    <constructor-arg type="java.lang.String" value="42"/>
</bean>

②使用index，index从0开始

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg index="0" value="7500000"/>
    <constructor-arg index="1" value="42"/>
</bean>

③使用name，

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg name="years" value="7500000"/>
    <constructor-arg name="ultimateAnswer" value="42"/>
</bean>

Keep in mind that, to make this work out of the box, your code must be compiled with the debug flag enabled so that Spring can look up the parameter name from the constructor. If you cannot or do not want to compile your code with the debug flag, you can use @ConstructorProperties JDK annotation to explicitly name your constructor arguments. The sample class would then have to look as follows:

package examples;

public class ExampleBean {

    // Fields omitted

    @ConstructorProperties({"years", "ultimateAnswer"})
    public ExampleBean(int years, String ultimateAnswer) {
        this.years = years;
        this.ultimateAnswer = ultimateAnswer;
    }
}

setter-based
spring团队提倡使用CDI，对于必须的依赖选择CDI，对于可选的依赖使用SDI，有的场景不得不使用SDI，比如要求可以重新配置或赋值的bean，再比如循环依赖，则必须对其中一个使用SDI
①SDI

<bean id="exampleBean" class="examples.ExampleBean">
    <!-- setter injection using the nested ref element -->
    <property name="beanOne">
        <ref bean="anotherExampleBean"/>
    </property>

    <!-- setter injection using the neater ref attribute -->
    <property name="beanTwo" ref="yetAnotherBean"/>
    <property name="integerProperty" value="1"/>
</bean>

<bean id="anotherExampleBean" class="examples.AnotherBean"/>
<bean id="yetAnotherBean" class="examples.YetAnotherBean"/>

public class ExampleBean {

    private AnotherBean beanOne;

    private YetAnotherBean beanTwo;

    private int i;

    public void setBeanOne(AnotherBean beanOne) {
        this.beanOne = beanOne;
    }

    public void setBeanTwo(YetAnotherBean beanTwo) {
        this.beanTwo = beanTwo;
    }

    public void setIntegerProperty(int i) {
        this.i = i;
    }
}

②CDI

<bean id="exampleBean" class="examples.ExampleBean">
    <!-- constructor injection using the nested ref element -->
    <constructor-arg>
        <ref bean="anotherExampleBean"/>
    </constructor-arg>

    <!-- constructor injection using the neater ref attribute -->
    <constructor-arg ref="yetAnotherBean"/>

    <constructor-arg type="int" value="1"/>
</bean>

<bean id="anotherExampleBean" class="examples.AnotherBean"/>
<bean id="yetAnotherBean" class="examples.YetAnotherBean"/>

public class ExampleBean {

    private AnotherBean beanOne;

    private YetAnotherBean beanTwo;

    private int i;

    public ExampleBean(
        AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {
        this.beanOne = anotherBean;
        this.beanTwo = yetAnotherBean;
        this.i = i;
    }
}

③静态工厂方法

<bean id="exampleBean" class="examples.ExampleBean" factory-method="createInstance">
    <constructor-arg ref="anotherExampleBean"/>
    <constructor-arg ref="yetAnotherBean"/>
    <constructor-arg value="1"/>
</bean>

<bean id="anotherExampleBean" class="examples.AnotherBean"/>
<bean id="yetAnotherBean" class="examples.YetAnotherBean"/>

public class ExampleBean {

    // a private constructor
    private ExampleBean(...) {
        ...
    }

    // a static factory method; the arguments to this method can be
    // considered the dependencies of the bean that is returned,
    // regardless of how those arguments are actually used.
    public static ExampleBean createInstance (
        AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {

        ExampleBean eb = new ExampleBean (...);
        // some other operations...
        return eb;
    }
}

ref
<bean id="" ref="">，ref可以引用同一IOC容器或父容器中的bean，不管是不是定义在同一个xml文件中
idref
集合

<bean id="moreComplexObject" class="example.ComplexObject">
    <!-- results in a setAdminEmails(java.util.Properties) call -->
    <property name="adminEmails">
        <props>
            <prop key="administrator">administrator@example.org</prop>
            <prop key="support">support@example.org</prop>
            <prop key="development">development@example.org</prop>
        </props>
    </property>
    <!-- results in a setSomeList(java.util.List) call -->
    <property name="someList">
        <list>
            <value>a list element followed by a reference</value>
            <ref bean="myDataSource" />
        </list>
    </property>
    <!-- results in a setSomeMap(java.util.Map) call -->
    <property name="someMap">
        <map>
            <entry key="an entry" value="just some string"/>
            <entry key ="a ref" value-ref="myDataSource"/>
        </map>
    </property>
    <!-- results in a setSomeSet(java.util.Set) call -->
    <property name="someSet">
        <set>
            <value>just some string</value>
            <ref bean="myDataSource" />
        </set>
    </property>
</bean>

·depends-on，保证自己所依赖的项在自己创建之前创建

<bean id="beanOne" class="ExampleBean" depends-on="manager,accountDao">
    <property name="manager" ref="manager" />
</bean>

<bean id="manager" class="ManagerBean" />
<bean id="accountDao" class="x.y.jdbc.JdbcAccountDao" />

scope为singleton的bean，和有默认值的bean在IOC容器创建的时候被创建，需要懒加载可以使用lazy-init属性

scope

image.png

proxy-target-class属性
false为jdk动态代理，true为cglib动态代理

生命周期callback函数

构建后和销毁前
Multiple lifecycle mechanisms configured for the same bean, with different initialization methods, are called as follows:

Methods annotated with @PostConstruct
afterPropertiesSet() as defined by the InitializingBean callback interface
A custom configured init() method

Destroy methods are called in the same order:

Methods annotated with @PreDestroy
destroy() as defined by the DisposableBean callback interface
A custom configured destroy() method

使用注解需要开启`<context:annotation-config/>`

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

@Autowired @Inject @Resource @Value
JavaConfig方式@Configuration @Bean @Import
@Configuration和@Bean一起使用
@Import
@Configuration用在类上，@Bean用在方法上，该方法返回一个对象，将返回的对象注册到IOC容器中，注册的bean的name就是方法名
@Primary @Qualifier
@Autowired是根据类型来匹配的，如果存在多个condidates，我们使用@Primary @Qualifier来指明精确的匹配
@Resource(name="")

@Configuration
public class MovieConfiguration {

    @Bean
    @Primary
    public MovieCatalog firstMovieCatalog() { ... }

    @Bean
    public MovieCatalog secondMovieCatalog() { ... }

    // ...
}

public class MovieRecommender {

    @Autowired
    private MovieCatalog movieCatalog;

    // ...
}

be equivalent to the following xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

    <bean class="example.SimpleMovieCatalog" primary="true">
        <!-- inject any dependencies required by this bean -->
    </bean>

    <bean class="example.SimpleMovieCatalog">
        <!-- inject any dependencies required by this bean -->
    </bean>

    <bean id="movieRecommender" class="example.MovieRecommender"/>

</beans>

public class MovieRecommender {

    @Autowired
    @Qualifier("main")
    private MovieCatalog movieCatalog;

    // ...
}

public class MovieRecommender {

    private MovieCatalog movieCatalog;

    private CustomerPreferenceDao customerPreferenceDao;

    @Autowired
    public void prepare(@Qualifier("main")MovieCatalog movieCatalog,
            CustomerPreferenceDao customerPreferenceDao) {
        this.movieCatalog = movieCatalog;
        this.customerPreferenceDao = customerPreferenceDao;
    }

    // ...
}

be equivalent to the following xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

    <bean class="example.SimpleMovieCatalog">
        <qualifier value="main"/> 

        <!-- inject any dependencies required by this bean -->
    </bean>

    <bean class="example.SimpleMovieCatalog">
        <qualifier value="action"/> 

        <!-- inject any dependencies required by this bean -->
    </bean>

    <bean id="movieRecommender" class="example.MovieRecommender"/>

</beans>

@RestController=@ResponseBody+Controller
开启自动扫描，自动检测被@Component, @Repository, @Service, @Controller注解的类，自动注册到IOC容器中，如果没指定name属性的值，自动注册的bean的name为类名首字母小写
xml方式<context:component-scan base-package="org.example"/>

@Service
public class SimpleMovieLister {

    private MovieFinder movieFinder;

    @Autowired
    public SimpleMovieLister(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }
}
@Repository
public class JpaMovieFinder implements MovieFinder {
    // implementation elided for clarity
}
//javaConfig方式
@Configuration
@ComponentScan(basePackages = "org.example")
public class AppConfig  {
    ...
}

AnnotationConfigApplicationContext

ClassPathXMLApplicationContext使用xml文件作为bean definition，AnnotationConfigApplicationContext使用注解

public static void main(String[] args) {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
    MyService myService = ctx.getBean(MyService.class);
    myService.doStuff();
}

@Respository @Service @Controller @Configuration这几个注解的定义上都有@Component注解，所以<context:component-scan />可以检测到

xml配置和javaConfig配置结合使用

xml为主，JavaConfig为辅
开启<context:anotation-config />或<context:component-scan />，然后在代码中使用注解
JavaConfig为主，xml为辅
使用@ImportResource导入xml文件

@Configuration
@ImportResource("classpath:/com/acme/properties-config.xml")
public class AppConfig {

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource() {
        return new DriverManagerDataSource(url, username, password);
    }
}

xml文件

properties-config.xml
<beans>
    <context:property-placeholder location="classpath:/com/acme/jdbc.properties"/>
</beans>

jdbc.properties文件

jdbc.properties
jdbc.url=jdbc:hsqldb:hsql://localhost/xdb
jdbc.username=sa
jdbc.password=

public static void main(String[] args) {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
    TransferService transferService = ctx.getBean(TransferService.class);
    // ...
}

profile

不同的环境下（开发，测试，生产环境），不同的配置

开启profile

注解方式，如@Profile("development")
xml方式，如<beans profile="development">

激活profile

代码方式

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.getEnvironment().setActiveProfiles("development");
ctx.register(SomeConfig.class, StandaloneDataConfig.class, JndiDataConfig.class);
ctx.refresh();

系统变量方式
-Dspring.profiles.active="development"

Resource接口

表示资源，重要的方法有getInputStream()，多个实现UrlResource
ClassPathResource，FileSystemResource，ServletContextResource
InputStreamResource，ByteArrayResource

ResourceLoader接口

方法为getResource(String location)，所有的ApplicationContext的实现都实现了这个接口

Validator ValidationUtils

supports(Class c)
validate(Object target, Errors errors)

Converter

package org.springframework.core.convert.converter;

public interface Converter<S, T> {

    T convert(S source);
}

SpEL

AOP

concepts

Aspect
Advise（5种类型，在join point上要干的事）
join point（通常是一个方法执行）
pointcut（pointcut expression）
target object（目标对象）
Proxy（代理，jdk动态代理或cglib代理）
weaving（织入的时机可以是编译，加载，运行时）
Introduction（给被代理的对象引入额外的的接口实现）

types of advise

before
after return（正常结束）
after exception（异常退出）
after（finally，无论哪种退出方式）
around（环绕通知，前后都可以定义定制化的操作，可以选择是否进入join point的执行流程，也可以shortcut advised method execution）

AspectJ

enable aspectj supports
<aop:aspectj-autoproxy/>
define aspect

annotation-stytle
@Aspect @Component(为了能使用扫描器)
xml-style

pointcut expression format
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
修饰符返回值类型全限定类名方法名参数异常，除了execution操作符还可以使用within target annotation args bean等操作符
advise body可以获取advised method 的参数，返回值，异常

@Pointcut("com.xyz.myapp.SystemArchitecture.dataAccessOperation() && args(account,..)")
private void accountDataAccessOperation(Account account) {}

@Before("accountDataAccessOperation(account)")
public void validateAccount(Account account) {
    // ...
}

xml形式

<aop:config>

    <aop:aspect id="myAspect" ref="aBean">

        <aop:pointcut id="businessService"
            expression="execution(* com.xyz.myapp.service..(..)) and this(service)"/>

        <aop:before pointcut-ref="businessService" method="monitor"/>
<!-- 或者
        <aop:before pointcut="execution(* com.xyz.myapp.service..(..)) and this(service)" method="monitor"/>
-->

        ...
    </aop:aspect>
</aop:config>

<bean id="aBean" class="">
  ...
</bean>

Aspect代码

public void monitor(Object service) {
    ...
}

after return

<aop:aspect id="afterReturningExample" ref="aBean">

    <aop:after-returning
        pointcut-ref="dataAccessOperation"
        returning="retVal"
        method="doAccessCheck"/>

    ...

</aop:aspect>

corresponding to java code

public void doAccessCheck(Object retVal) {...}

<aop:config>

    <aop:pointcut id="businessService"
        expression="execution(* com.xyz.myapp.service.*.*(..))"/>

    <aop:advisor
        pointcut-ref="businessService"
        advice-ref="tx-advice"/>

</aop:config>

<tx:advice id="tx-advice">
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

force to use cglib proxy

<aop:config proxy-target-class="true">
    <!-- other beans defined here... -->
</aop:config>

<aop:aspectj-autoproxy proxy-target-class="true"/>

transation

PlatformTransactionManager

public interface PlatformTransactionManager {

    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

    void commit(TransactionStatus status) throws TransactionException;

    void rollback(TransactionStatus status) throws TransactionException;
}

@Transactional @EnableTransactionManagement
<tx:advice/>
advisor相当于只有一个方法的aspect

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- this is the service object that we want to make transactional -->
    <bean id="fooService" class="x.y.service.DefaultFooService"/>

    <!-- the transactional advice (what 'happens'; see the <aop:advisor/> bean below) -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <!-- the transactional semantics... -->
        <tx:attributes>
            <!-- all methods starting with 'get' are read-only -->
            <tx:method name="get*" read-only="true"/>
            <!-- other methods use the default transaction settings (see below) -->
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

    <!-- ensure that the above transactional advice runs for any execution
        of an operation defined by the FooService interface -->
    <aop:config>
        <aop:pointcut id="fooServiceOperation" expression="execution(* x.y.service.FooService.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceOperation"/>
    </aop:config>

    <!-- don't forget the DataSource -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
        <property name="url" value="jdbc:oracle:thin:@rj-t42:1521:elvis"/>
        <property name="username" value="scott"/>
        <property name="password" value="tiger"/>
    </bean>

    <!-- similarly, don't forget the PlatformTransactionManager -->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- other <bean/> definitions here -->

</beans>

默认回滚策略是发生了未处理的unchecked exception，checked exception默认不回滚

配置回滚的异常

<tx:advice id="txAdvice" transaction-manager="txManager">
    <tx:attributes>
    <tx:method name="get*" read-only="true" rollback-for="NoProductInStockException"/>
    <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

配置特定异常不回滚

<tx:advice id="txAdvice">
    <tx:attributes>
    <tx:method name="updateStock" no-rollback-for="InstrumentNotFoundException"/>
    <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

<tx:advice>settings

annotation-based transaction
@EnableTransactionManagement @Transactional

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- this is the service object that we want to make transactional -->
    <bean id="fooService" class="x.y.service.DefaultFooService"/>

    <!-- enable the configuration of transactional behavior based on annotations -->
    <tx:annotation-driven transaction-manager="txManager"/><!-- a PlatformTransactionManager is still required --> 

    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- (this dependency is defined somewhere else) -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- other <bean/> definitions here -->

</beans>

programmatic transaction

Using the TransactionTemplate
Using the PlatformTransactionManager

spring mvc

DispacherServlet
HandlerMapping

RequestMappingHandlerMapping
SimpleUrlHandlerMapping

<!-- 配置Handler -->   
<bean id="hello1" class="com.ys.controller.HelloController" />
<bean id="hello2" class="com.ys.controller.HelloController" />
<!-- 第二种方法：简单URL配置处理器映射器 -->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <props>
            <prop key="/hello1.do">hello1</prop>
            <prop key="/hello2.do">hello2</prop>
        </props>
    </property>
</bean>

BeanNameUrlHandlerMapping(bean的name作为url)

HandlerAdapter

SimpleControllerHandlerAdapter（handler需要直接或间接实现Controller）

SimpleControllerHandlerAdapter
HttpRequestHandlerAdapter（handler需要直接或间接实现HttpRequestHandler，public void handleRequest(HttpServletRequest request, HttpServletResponse response)，没有返回值，可以通过转发、重定向、直接response.getWriter().write()）

HttpRequestHandlerAdapter

ViewResolver

InternalResourceViewResolver

<!-- 配置视图解析器
    进行jsp解析，默认使用jstl标签，classpath下得有jstl的包，如果这样配，那么在 Handler 中返回的必须是路径+jsp页面名称+".jsp"-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" />

<!--配置视图解析器  如果这样配，那么在 Handler 中只需要返回在 view 文件夹下的jsp 页面名就可以了-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 返回视图页面的前缀 -->
        <property name="prefix" value="/WEB-INF/view"></property>
        <!-- 返回页面的后缀 -->
        <property name="suffix" value=".jsp"></property>
    </bean>

DispatcherServlet.properties
如果用户没有配置springmvc全局配置文件，就会使用这个
HandlerExceptionResolver
HandlerInterceptor

参数绑定

@RequestParam @RequestHeader @CookieValue @PathVariable @ModelAttribute

ResponseEntity RequestEntity包含header和body
CORS
@CrossOrigin

<mvc:cors>

    <mvc:mapping path="/api/**"
        allowed-origins="http://domain1.com, http://domain2.com"
        allowed-methods="GET, PUT"
        allowed-headers="header1, header2, header3"
        exposed-headers="header1, header2" allow-credentials="true"
        max-age="123" />

    <mvc:mapping path="/resources/**"
        allowed-origins="http://domain1.com" />

</mvc:cors>

FreeMarker模板引擎

<mvc:annotation-driven/>

<mvc:view-resolvers>
    <mvc:freemarker/>
</mvc:view-resolvers>

<!-- Configure FreeMarker... -->
<mvc:freemarker-configurer>
    <mvc:template-loader-path location="/WEB-INF/freemarker"/>
</mvc:freemarker-configurer>

Controller接口

可以实现Controller接口或继承AbstractController抽象类，或者带有@Controller注解的普通类

public interface Controller {
       ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
}

AbstractController抽象类实现了Controller

缓存

cache头信息， Cache-Control ：max-age=cacheSeconds
If-Modified-Since
etag

spring5.14参考文档

AOP面向切面编程

其他注解

spring核心组件

IOC（xml注册（单个或包扫描），注解注册，DefaultListableBeanFactory代码注册）

DI（xml配置，注解）

scope

生命周期callback函数

使用注解需要开启`<context:annotation-config/>`

AnnotationConfigApplicationContext

xml配置和javaConfig配置结合使用

profile

Resource接口

ResourceLoader接口

Validator ValidationUtils

Converter

SpEL

AOP

AspectJ

transation

spring mvc

参数绑定

FreeMarker模板引擎

Controller接口

AbstractController抽象类实现了Controller

缓存

猜你喜欢

热点阅读

spring5.14参考文档

AOP面向切面编程

其他注解

spring核心组件

IOC（xml注册（单个或包扫描），注解注册，DefaultListableBeanFactory代码注册）

DI（xml配置，注解）

scope

生命周期callback函数

使用注解需要开启<context:annotation-config/>

AnnotationConfigApplicationContext

xml配置和javaConfig配置结合使用

profile

Resource接口

ResourceLoader接口

Validator ValidationUtils

Converter

SpEL

AOP

AspectJ

transation

spring mvc

参数绑定

FreeMarker模板引擎

Controller接口

AbstractController抽象类实现了Controller

缓存

猜你喜欢

热点阅读

使用注解需要开启`<context:annotation-config/>`