>

Spring入门程序,知识点总结

- 编辑:金沙国际平台登录 -

Spring入门程序,知识点总结

  1. 开创叁个Maven的品类,我的品类布局如下:
    图片 1
  2. 在pom文件里写下需求导入的依赖:

  小编不提议过多的看那一个框架的代码,因为那一个代码要到位职分急需过多零碎的类完成,譬如读取有些包上边包车型地铁全部类,深入分析class的头文件,反射各类音讯,再增进封装,很有一点都不小可能率在读源码的进度中掉到各个细节里出不来,所以读这种源码要事无巨细,通晓原理就能够。基本原理其实正是透过反射深入分析类及其类的种种音讯,包蕴构造器、方法及其参数,属性。然后将其封装成bean定义音信类、constructor消息类、method音信类、property消息类,最后放在贰个map里,也正是所谓的container,池等等,其实就是个map。

         BeanFactory和BeanDefinition,叁个是IOC的为主工厂接口,四个是IOC的bean定义接口,上章提到说我们不能够让BeanFactory持有一个Map<String,Object>来产生bean工厂的法力,是因为spring的开始化是足以决定的,能够到用的时候才将bean实例化供开辟者使用,除非大家将bean的lazy-init属性设置为true,早先化bean工厂时选用延迟加载。

    <?xml version="1.0" encoding="UTF-8"?>    <project xmlns="http://maven.apache.org/POM/4.0.0"         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0          http://maven.apache.org/xsd/maven-4.0.0.xsd">       <modelVersion>4.0.0</modelVersion>       <groupId>com.abc</groupId>       <artifactId>01-first</artifactId>       <version>1.0-SNAPSHOT</version>       <build>           <plugins>               <plugin>                   <groupId>org.apache.maven.plugins</groupId>                   <artifactId>maven-compiler-plugin</artifactId>                   <configuration>                       <source>6</source>                      <target>6</target>                   </configuration>               </plugin>           </plugins>       </build>       <properties>           <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>           <maven.compiler.source>10</maven.compiler.source>           <maven.compiler.target>10</maven.compiler.target>           <spring.version>5.1.0.RELEASE</spring.version>       </properties>       <dependencies>           <dependency>               <groupId>org.springframework</groupId>               <artifactId>spring-beans</artifactId>               <version>${spring.version}</version>           </dependency>           <dependency>               <groupId>org.springframework</groupId>               <artifactId>spring-core</artifactId>               <version>${spring.version}</version>           </dependency>           <dependency>               <groupId>org.springframework</groupId>               <artifactId>spring-context</artifactId>               <version>${spring.version}</version>           </dependency>           <dependency>               <groupId>org.springframework</groupId>               <artifactId>spring-expression</artifactId>               <version>${spring.version}</version>           </dependency>           <dependency>               <groupId>org.springframework</groupId>               <artifactId>spring-jcl</artifactId>               <version>${spring.version}</version>           </dependency>           <dependency>               <groupId>junit</groupId>               <artifactId>junit</artifactId>               <version>4.12</version>               <scope>test</scope>           </dependency>       </dependencies>       <build>           <plugins>               <plugin>                   <artifactId>maven-compiler-plugin</artifactId>                   <configuration>                       <source>1.10</source>                       <target>1.10</target>                   </configuration>               </plugin>           </plugins>       </build>     </project>

          那么透亮了上述七个接口,笔者信任广大人竟是不看源码都曾经猜到spring是何许做的了。没有错,正是让bean工厂持有三个Map<String,BeanDefinition>,那样就足以在其他时候大家想用哪个bean,取到它的bean定义,大家就足以创建出多个非同小可的实例。

  1. 在Java文件夹下新建package,在package包下新建接口及其完毕类
    接口:
    public interface SomeService { void doSome(); }
    实现类:

        public class SomeServiceImpl implements SomeService {    public SomeServiceImpl() {        System.out.println("创建SomeServiceImpl对象");    }    @Override    public void doSome() {        System.out.println("执行SomeServiceImpl里的doSome;    }    }
    
  2. 在resources目录下新建applicationContext.xml文件

      当您写好布署文件,运转项目后,框架会先遵照你的布置文件找到十二分要scan的包,然后分析包里面包车型客车全部类,找到全部含有@bean,@service等注脚的类,利用反射分析它们,包罗解析构造器,方法,属性等等,然后封装成各样新闻类放到贰个map里。每当你需求一个bean的时候,框架就能从container找是或不是有那一个类的概念啊?假设找到则通过构造器new出来(那正是决定反转,不用您new,框架帮您new),再在这几个类找是否有要注入的性质或然措施,比方标有@autowired的习性,假如有则依旧到container找对应的分析类,new出目的,并由这事先分析出来的音讯类找到setter方法,然后用该方法注入对象(那就是凭仗注入)。若是内部有一个类container里没找到,则抛出极其,举例大范围的spring不能找到此类定义,不只怕wire的充足。还会有正是嵌套bean则用了一晃递归,container会放到servletcontext里面,每回reQuest从servletcontext找这一个container就可以,不用一再分析类定义。若是bean的scope是singleton,则会援用那一个bean不再另行创设,将以此bean放到一个map里,每一回用都先从那个map里面找。就算scope是session,则该bean会放到session里面。仅此而已,没须要花更加多精力。建议还是多看看底层的文化。

  • 我们须求在spring容器的配备文件中张开挂号该Bean
  • spring使用的陈设文件为xml文件,当然须求引进约束文件,一般将spring的配备文件命名称为applicationContext.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"            xsi:schemaLocation="http://www.springframework.org/schema/beans           http://www.springframework.org/schema/beans/spring-beans.xsd">         <!--注册Servcie其造价于如下代码:   SomeServiceImpl someService = new SomeServiceImpl();                其底层是通过反射机制创建的someService对象        Object someService = Class.forName("com.abc.service.SomeServiceImpl").newInstance();-->                <bean  /> </beans>
    
  • spring的根成分是benas明显是注册Bean,子标签是Bean

  • 注册:<bean />
  • id属性为了独一分明三个指标,class属性里边应写类全名

1afterPropertiesSet与init-method

  1. 挂号结束后大家要在测量试验类中获取spring容器,而赢得Spring容器有三种方法。

(1)、init-method方法,伊始化bean的时候施行,能够本着有些具体的bean进行配置。init-method须要在applicationContext.xml配置文书档案中bean的定义里头写明。举个例子:<bean id="TestBean" class="nju.software.xkxt.util.TestBean" init-method="init"></bean>
如此那般,当TestBean在早先化的时候会实行TestBean中定义的init方法。   
(2)、afterPropertiesSet方法,初步化bean的时候实行,可以本着某些具体的bean进行安插。afterPropertiesSet 必须完成 InitializingBean接口。实现InitializingBean接口必须兑现afterPropertiesSet方法。 InitializingBean是贰个接口,它独自包括二个主意:afterPropertiesSet()。Spring供给init-method是一个无参数的方法,如果init-method内定的法子中有参数,那么Spring将会抛出万分init-method内定的办法能够是public、protected以及private的,并且方法也得以是final的。
(3)、BeanPostProcessor,针对富有Spring上下文中负有的bean,能够在配置文书档案applicationContext.xml中布署四个BeanPostProcessor,然后对持有的bean进行二个起先化方法在此以前和将来的代理。BeanPostProcessor接口中有多少个方法: postProcessBeforeInitialization和postProcessAfterInitialization。后边二个postProcessBeforeInitialization在实例化及信赖注入完毕后、在任何起先化代码(举例配置文件中的init-method)调用以前调用;前者postProcessAfterInitialization在初叶化代码调用之后调用
 postProcessBeforeInitialization方法在bean初步化在此之前执行, postProcessAfterInitialization方法在bean伊始化之后推行。

图片 2

    package com.abc.service;    import org.junit.Test;    import org.springframework.context.ApplicationContext;    import org.springframework.context.support.ClassPathXmlApplicationContext;    import org.springframework.context.support.FileSystemXmlApplicationContext;    public class SomeServiceImplTTest {         // spring容器获取的两种方式         @Test         public void test01(){             //在类路径下加载Spring配置文件             ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");             //在当前目录的根下加载该配置文件,路径应为文件实际存放的目录                ApplicationContext ac2 = new FileSystemXmlApplicationContext                       ("D:\IDEA-workspace\01-first\src\main\resources\applicationContext.xml");                System.out.println;          }            @Test        public void test02() {             // 加载Spring配置文件,创建Spring容器对象             ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");             //调用spring容器的getBean方法获取carImpl,方法参数为bean的id             SomeService service = (SomeService) ac.getBean("SomeService");             service.doSome();            }        }

2 proxy-target-class 功效 该属性值默认为false,表示使用JDK动态代理织入巩固;当班值日为true时,表示使用CGLib动态代理织入巩固;不过,就算设置为false,要是目的类未有生命接口,则spring将电动使用CGLib动态代理
当要动用完成了某些接口的类让spring来生成bean时,无需在aop配置中添加proxy-target-class,因为它私下认可为false.

Spring入门程序到此就得了了

2 lazy-init详解成效 该属性值默感觉false,表示ApplicationContext实现的默许行为正是在运维时将享有singleton bean提前举行实例化(也正是借助注入),lazy-init 设置只对scop属性为singleton的bean起效率。

3 Spring bean功效域与生命周期

 参考小说:Spring BeanBean的功效域及生命周期

实例化。Spring通过new关键字将八个Bean举办实例化,JavaBean都有暗中认可的构造函数,因而不要求提供协会参数。填入属性。Spring依照xml文件中的配置通过调用Bean中的setXXX方法填入对应的特性。事件通报。Spring依次检查Bean是或不是落到实处了BeanNameAware、BeanFactoryAware、ApplicationContextAware、BeanPostProcessor、InitializingBean接口,假使有的话,依次调用那几个接口。使用。应用程序能够符合规律使用这么些Bean了。销毁。假使Bean达成了DisposableBean接口,就调用其destroy方法。

留意:即使bean的scope设为prototype时,当ctx.close时,destroy方法不会被调用.

案由:对于prototype成效域的bean,有好几要命首要,这正是Spring不可能对二个prototype bean的上上下下生命周期担当:容器在开头化、配置、装饰依旧是装配完贰个prototype实例后,将它交给客商端,随后就对该prototype实例数见不鲜了。不管何种效用域,容器都会调用全数指标的初叶化生命周期回调方法。但对prototype来讲,任何配置好的析构生命周期回调方法都将不会 被调用。清除prototype成效域的靶子并释放别的prototype bean所具有的昂贵能源,都是客商端代码的职分。(让Spring容器释放被prototype成效域bean占用能源的一种有效措施是,通过利用bean的前置管理器,该Computer持有要被免去的bean的引用。)谈及prototype功能域的bean时,在一些地点你可以将Spring容器的剧中人物作为是Java new 操作的代替者。任何迟于该时间点的生命周期事宜都得交由客户端来处理。
4 BeanDefinition的载入和分析

对IoC容器来讲,那一个载入进度,约等于把定义的BeanDefinition在IoC容器中间转播化成叁个Spring内部表示的数据结构的进度。IoC容器对Bean的管理和信赖注入功用的兑现,是经过对其持有的BeanDefinition实行各个相关操作来变成的。那几个BeanDefinition数据在IoC容器中经过一个HashMap来保持和保护。当然那只是一种比较轻巧的掩护方式,假设急需狠抓IoC容器的性格和体量,完全能够团结做一些恢弘。

IoC容器的开首化入口,也正是看一下refresh方法。那个法子的早先时期是在FileSystemXmlApplicationContext的构造函数中被调用的,它的调用标识着容器初步化的初叶,
这一个开首化对象就是Bean. 

 

4 Spring容器初步化进程

spring的IoC容器初叶化包罗:Bean定义财富文件的固化、载入和挂号3个宗旨进度。当 BeanDefinition 注册结束之后, Spring Bean 工厂就足以随时依照需求开展实例化了。对于 XmlBeanFactory 来讲,实例化暗中同意是延迟进行的,也正是说在 getBean 的时候才会;而对于 ApplicationContext 来讲,实例化会在容器运营后经过AbstractApplicationContext 中 reflash 方法自动进行,首要通过方法链: reflesh()   à finishBeanFactoryInitialization (factory) à DefaultListableBeanFactory.preInstantiateSingletons (), 在此处会依据登记的 BeanDefinition 消息依此调用 getBean(beanName) 。而真的实例化的逻辑和 BeanFactory 是“不期而遇”的,全体关于 Bean 实例化都得以从 getBean(beanName) 入手。IoC容器和上下文初始化一般不含有Bean信赖注入的贯彻。一般而言,信赖注入发送在使用第一遍通过getBean方法向容器获取Bean时。可是有个特例是:IoC容器预实例化配置的lazyinit属性,借使有个别Bean设置了lazyinit属性,则该Bean的借助注入在IoC容器最初化时就优先实现了

5 怎样运转spring容器:在Web项目中,运营Spring容器的主意有二种,ContextLoaderListener、ContextLoadServlet、ContextLoaderPlugin。

5 ApplicationContext和beanfactory差别:BeanFacotry是spring中相比较原始的Factory。如XMLBeanFactory正是一种规范的BeanFactory。原始的BeanFactory不能够援助spring的广大插件,如AOP功能、Web应用等。 ApplicationContext接口,它由BeanFactory接口派生而来,因此提供BeanFactory全数的意义

参照小说:Spring中ApplicationContext和beanfactory区别 .

 6 spring如何跟struts2: struts2-spring-plugin.jar这些插件重写了struts的对象工厂,当创造三个action类时,它会依赖struts的配备文件的class属性的值与spring配置文件中的id属性的值相相称

参谋小说:spring与struts2结合

 7 spring怎么着跟mybatis:Mybatis-Spring给我们封装了三个SqlSessionFactoryBean,那么些指标蕴涵了3个要求属性,分别是数据源、扫描xml和扫描dao层用的

 

[html] view plain copy

 

  1. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
  2.               <property name="dataSource" ref="dataSource" />  
  3.               <property name="mapperLocations"  
  4.                      value="classpath:com/tiantian/ckeditor/mybatis/mappers/*Mapper.xml" />  
  5.               <property name="typeAliasesPackage" value="com.tiantian.ckeditor.model" />  
  6. </bean>  

 

mapperLocations:它意味着大家的Mapper文件存放的职责,当大家的Mapper文件跟对应的Mapper接口处于同壹人置的时候能够不用钦赐该属性的值。

configLocation:用于钦定Mybatis的布局文件地方。如若钦定了该属性,那么会以该配置文件的开始和结果作为配置音信营造对应的SqlSessionFactoryBuilder,可是后续属性钦点的剧情会覆盖该配置文件之中钦定的附和内容。

 type阿里asesPackage:它一般对应大家的实体类所在的包,这年会自行取对应包中不包含包名的简短类名作为包含包名的别称。多少个package之间能够用逗号或许分部等来拓宽分隔。

自我不提议过多的看那个框架的代码,因为那个代码要做到职责急需多多零碎的类完结,比方读取某些包下边包车型大巴全部类,分析class的头文件,反射种种信息,再增加封装,很有极大概率在读源码的经过中掉到各个细节里出不来,所以读这种源码要事无巨细,掌握原理就可以。基本原理其实正是因此反射分析类及其类的各种音讯,蕴含构造器、方法及其参数,属性。然后将其封装成bean定义消息类、constructor消息类、method新闻类、property消息类,最后放在二个map里,也正是所谓的container,池等等,其实正是个map。

         BeanFactory和BeanDefinition,多个是IOC的为主工厂接口,多个是IOC的bean定义接口,上章提到说大家不恐怕让BeanFactory持有八个Map<String,Object>来成功bean工厂的功能,是因为spring的最初化是能够决定的,能够到用的时候才将bean实例化供开拓者使用,除非大家将bean的lazy-init属性设置为true,开头化bean工厂时选取延迟加载。

          那么透亮了上述三个接口,作者信任广大人竟是不看源码都曾经猜到spring是何许做的了。没有错,正是让bean工厂持有贰个Map<String,BeanDefinition>,那样就足以在别的时候大家想用哪个bean,取到它的bean定义,我们就能够创设出一个分裂平日的实例。

      当您写好安插文件,运维项目后,框架会先根据你的配置文件找到十一分要scan的包,然后剖判包里面包车型大巴全数类,找到全部含有@bean,@service等申明的类,利用反射分析它们,满含解析构造器,方法,属性等等,然后封装成各类音讯类放到多少个map里。每当你必要叁个bean的时候,框架就能够从container找是否有其一类的概念啊?假如找到则经过构造器new出来(那正是决定反转,不用您new,框架帮您new),再在那几个类找是或不是有要注入的质量或然措施,比如标有@autowired的性质,假设有则照旧到container找对应的剖析类,new出指标,并经过事先剖析出来的新闻类找到setter方法,然后用该措施注入对象(那正是借助注入)。要是内部有一个类container里没找到,则抛出特别,举例大范围的spring不可能找到此类定义,不可能wire的不行。还会有便是嵌套bean则用了弹指间递归,container会放到servletcontext里面,每回reQuest从servletcontext找这几个container就能够,不用反复分析类定义。借使bean的scope是singleton,则会引用这一个bean不再另行创立,将以此bean放到一个map里,每便用都先从那个map里面找。假使scope是session,则该bean会放到session里面。仅此而已,没要求花更加多精力。建议依旧多看看底层的学问。

1afterPropertiesSet与init-method

(1)、init-method方法,初叶化bean的时候试行,能够针对有些具体的bean举行布局。init-method供给在applicationContext.xml配置文档中bean的定义里头写明。例如:<bean id="TestBean" class="nju.software.xkxt.util.TestBean" init-method="init"></bean>
这么,当TestBean在开始化的时候会实践TestBean中定义的init方法。   
(2)、afterPropertiesSet方法,初阶化bean的时候推行,能够本着某些具体的bean进行配置。afterPropertiesSet 必需兑现 InitializingBean接口。实现InitializingBean接口必得兑现afterPropertiesSet方法。 InitializingBean是两个接口,它仅仅包含五个方法:afterPropertiesSet()。Spring要求init-method是三个无参数的主意,若是init-method钦定的主意中有参数,那么Spring将会抛出非常init-method钦定的章程能够是public、protected以及private的,何况方法也得以是final的。
(3)、BeanPostProcessor,针对富有Spring上下文中全体的bean,能够在计划文书档案applicationContext.xml中安插叁个BeanPostProcessor,然后对富有的bean举办贰个初阶化方法以前和今后的代办。BeanPostProcessor接口中有三个方法: postProcessBeforeInitialization和postProcessAfterInitialization。前面三个postProcessBeforeInitialization在实例化及重视注入实现后、在别的最初化代码(比如配置文件中的init-method)调用在此之前调用;前者postProcessAfterInitialization在起先化代码调用之后调用
 postProcessBeforeInitialization方法在bean初阶化在此之前实行, postProcessAfterInitialization方法在bean初步化之后实行。

图片 3

2 proxy-target-class 作用 该属性值默以为false,表示使用JDK动态代理织入巩固;当班值日为true时,表示使用CGLib动态代理织入巩固;可是,即使设置为false,如果指标类未有生命接口,则spring将活动使用CGLib动态代理
当要使用实现了某个接口的类让spring来生成bean时,没有须求在aop配置中加多proxy-target-class,因为它默感到false.

2 lazy-init详解功用 该属性值默感觉false,表示ApplicationContext完毕的默许行为正是在运维时将享有singleton bean提前进行实例化(也正是正视注入),lazy-init 设置只对scop属性为singleton的bean起功能。

3 Spring bean效用域与生命周期

 仿效小说:Spring BeanBean的功效域及生命周期

实例化。Spring通过new关键字将二个Bean进行实例化,JavaBean都有默许的构造函数,因而无需提供组织参数。填入属性。Spring依据xml文件中的配置通过调用Bean中的setXXX方法填入对应的脾性。事件通报。Spring依次检查Bean是还是不是落到实处了BeanNameAware、BeanFactoryAware、ApplicationContextAware、BeanPostProcessor、InitializingBean接口,如若有的话,依次调用这几个接口。使用。应用程序能够日常使用这么些Bean了。销毁。假使Bean完成了DisposableBean接口,就调用其destroy方法。

潜心:假如bean的scope设为prototype时,当ctx.close时,destroy方法不会被调用.

案由:对于prototype功能域的bean,有少数非常首要,那正是Spring不可能对多个prototype bean的全部生命周期担负:容器在早先化、配置、装饰依然是装配完贰个prototype实例后,将它交给顾客端,随后就对该prototype实例闭关却扫了。不管何种功效域,容器都会调用全体指标的初阶化生命周期回调方法。但对prototype来说,任何配置好的析构生命周期回调方法都将不会 被调用。清除prototype功用域的目的并释放别的prototype bean所怀有的昂贵财富,都以客商端代码的职务。(让Spring容器释放被prototype效率域bean占用能源的一种有效措施是,通过选择bean的前置管理器,该管理器持有要被扫除的bean的引用。)谈及prototype功能域的bean时,在一些地点你能够将Spring容器的剧中人物当作是Java new 操作的代替者。任何迟于该时间点的生命周期事宜都得交由客户端来拍卖。
4 BeanDefinition的载入和深入分析

对IoC容器来讲,这些载入进度,也等于把定义的BeanDefinition在IoC容器中间转播化成二个Spring内部表示的数据结构的历程。IoC容器对Bean的治本和依赖性注入功能的兑现,是透过对其有着的BeanDefinition实行各个有关操作来成功的。那一个BeanDefinition数据在IoC容器中通过贰个HashMap来保持和护卫。当然那只是一种比较轻巧的保卫安全格局,假使急需加强IoC容器的质量和体量,完全能够本人做一些扩展。

IoC容器的开首化入口,也正是看一下refresh方法。那么些艺术的前期是在FileSystemXmlApplicationContext的构造函数中被调用的,它的调用标记着容器最早化的开头,
这几个初步化对象便是Bean. 

 

4 Spring容器初叶化进程

spring的IoC容器开始化包蕴:Bean定义财富文件的定位、载入和挂号3个为主历程。当 BeanDefinition 注册截至之后, Spring Bean 工厂就能够随时依照要求开展实例化了。对于 XmlBeanFactory 来讲,实例化私下认可是延迟举行的,也正是说在 getBean 的时候才会;而对此 ApplicationContext 来讲,实例化会在容器运转后经过AbstractApplicationContext 中 reflash 方法自动进行,首要透过方法链: reflesh()   à finishBeanFactoryInitialization (factory) à DefaultListableBeanFactory.preInstantiateSingletons (), 在那边会依照登记的 BeanDefinition 信息依此调用 getBean(beanName) 。而真的实例化的逻辑和 BeanFactory 是“不约而合”的,全数有关 Bean 实例化都能够从 getBean(beanName) 动手。IoC容器和左右文伊始化一般不含有Bean依赖注入的落到实处。一般来讲,注重注入发送在运用第三次通过getBean方法向容器获取Bean时。不过有个特例是:IoC容器预实例化配置的lazyinit属性,假如有些Bean设置了lazyinit属性,则该Bean的依据注入在IoC容器起头化时就先行达成了

5 怎样运行spring容器:在Web项目中,运转Spring容器的章程有三种,ContextLoaderListener、ContextLoadServlet、ContextLoaderPlugin。

5 ApplicationContext和beanfactory差异:BeanFacotry是spring中相比原始的Factory。如XMLBeanFactory正是一种规范的BeanFactory。原始的BeanFactory不能补助spring的居多插件,如AOP成效、Web应用等。 ApplicationContext接口,它由BeanFactory接口派生而来,由此提供BeanFactory全部的效果

参照小说:Spring中ApplicationContext和beanfactory区别 .

 6 spring如何跟struts2: struts2-spring-plugin.jar那个插件重写了struts的靶子工厂,当成立一个action类时,它会依照struts的安排文件的class属性的值与spring配置文件中的id属性的值相相配

参照他事他说加以考察小说:spring与struts2结合

 7 spring怎么着跟mybatis:Mybatis-Spring给大家封装了一个SqlSessionFactoryBean,那个指标包涵了3个要求属性,分别是数据源、扫描xml和扫描dao层用的

 

[html] view plain copy

 

  1. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
  2.               <property name="dataSource" ref="dataSource" />  
  3.               <property name="mapperLocations"  
  4.                      value="classpath:com/tiantian/ckeditor/mybatis/mappers/*Mapper.xml" />  
  5.               <property name="typeAliasesPackage" value="com.tiantian.ckeditor.model" />  
  6. </bean>  

 

mapperLocations:它意味着大家的Mapper文件寄存的职位,当我们的Mapper文件跟对应的Mapper接口处于同一职位的时候能够绝不钦定该属性的值。

configLocation:用于内定Mybatis的配置文件地点。假使钦点了该属性,那么会以该配置文件的剧情作为配置音讯创设对应的SqlSessionFactoryBuilder,可是后续属性钦命的内容会覆盖该配置文件之中内定的相应内容。

 typeAliasesPackage:它一般对应我们的实体类所在的包,今年会活动取对应包中不富含包名的简便类名作为富含包名的小名。四个package之间能够用逗号或许分集团等来进行分隔。

本文由编程发布,转载请注明来源:Spring入门程序,知识点总结