• Spring 学习笔记一


    1、IOC,DI。 2、装配bean基于xml(实例化,声明周期,后处理bean,属性注入)。3、装配bean基于注解

     

    1       spring框架概述

    1.1   什么是spring

    l    Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在

    其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了

    解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用

    哪一个组件,同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由

    EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,

    任何Java应用都可以从Spring中受益。Spring的核心是控制反转(IoC)面向切面(AOP)。简单来说,

    Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。

    l    轻量级:与EJB对比,依赖资源少,销毁的资源少。

    l    分层: 一站式,每一个层都提供的解决方案

             web层:struts,spring-MVC

             service层:spring

             dao层:hibernate,mybatis jdbcTemplate  --> spring-data

    1.2   spring由来

    l    Expert One-to-One J2EE Design and Development

    l    Expert One-to-One J2EE Development without EJB

    1.3   spring核心

    l  Spring的核心是控制反转(IoC面向切面(AOP

    1.4   spring优点

    l  方便解耦,简化开发  (高内聚低耦合)

    • Spring就是一个大工厂(容器),可以将所有对象创建和依赖关系维护,交给Spring管理
    • spring工厂是用于生成bean

    l  AOP编程的支持

    • Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能

    l  声明式事务的支持

    • 只需要通过配置就可以完成对事务的管理,而无需手动编程

    l  方便程序的测试

    • Spring对Junit4支持,可以通过注解方便的测试Spring程序

    l  方便集成各种优秀框架

    • Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz等)的直接支持

    l  降低JavaEE API的使用难度

    • Spring 对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低

    1.5   spring体系结构

     

    核心容器:beans、core、context、expression

    2       入门案例:IoC【掌握】

    2.1   导入jar包

    l  4 + 1  : 4个核心(beans、core、context、expression) + 1个依赖(commons-loggins...jar)

     

    2.2   目标类

    l  提供UserService接口和实现类

    l  获得UserService实现类的实例

           之前开发中,直接new一个对象即可。

           学习spring之后,将由Spring创建对象实例--> IoC 控制反转(Inverse of  Control)

                  之后需要实例对象时,从spring工厂(容器)中获得,需要将实现类的全限定名称配置到xml文件中

    public interface UserService {

      

       public void addUser();

     

    }

    public class UserServiceImpl implements UserService {

     

       @Override

       public void addUser() {

          System.out.println("a_ico add user");

       }

     

    }

    2.3   配置文件

    l  位置:任意,开发中一般在classpath下(src)

    l  名称:任意,开发中常用applicationContext.xml

    l  内容:添加schema约束

           约束文件位置:spring-framework-3.2.0.RELEASEdocsspring-framework-referencehtml xsd-config.html

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4        xsi:schemaLocation="http://www.springframework.org/schema/beans 
     5                               http://www.springframework.org/schema/beans/spring-beans.xsd">
     6     <!-- 配置service 
     7         <bean> 配置需要创建的对象
     8             id :用于之后从spring容器获得实例时使用的
     9             class :需要创建实例的全限定类名
    10     -->
    11     <bean id="userServiceId" class="com.itheima.a_ioc.UserServiceImpl"></bean>
    12 </beans>
    applicationContext.xml

    2.4   测试

     1 @Test
     2 
     3     public void demo02(){
     4 
     5         //从spring容器获得
     6 
     7         //1 获得容器
     8 
     9         String xmlPath = "com/itheima/a_ioc/beans.xml";
    10 
    11         ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    12 
    13         //2获得内容 --不需要自己new,都是从spring容器获得
    14 
    15         UserService userService = (UserService) applicationContext.getBean("userServiceId");
    16 
    17         userService.addUser();
    18 
    19        
    20 
    21     }
    TestDemo

    3   入门案例:DI【掌握】

    l  DI Dependency Injection ,依赖注入

           is a :是一个,继承。

           has a:有一个,成员变量,依赖。

                  class B {

               private A a;   //B类依赖A类

            }

           依赖:一个对象需要使用另一个对象

           注入:通过setter方法进行另一个对象实例设置。

    l  例如:

           class BookServiceImpl{

            //之前开发:接口 = 实现类  (service和dao耦合)

                  //private BookDao bookDao = new BookDaoImpl();

                 //spring之后 (解耦:service实现类使用dao接口,不知道具体的实现类)

                  private BookDao bookDao;

                  setter方法

       }

           模拟spring执行过程

           创建service实例:BookService bookService = new BookServiceImpl()          -->IoC  <bean>

           创建dao实例:BookDao bookDao = new BookDaoImple()                             -->IoC

           将dao设置给service:bookService.setBookDao(bookDao);                          -->DI   <property>

    3.1   目标类

    l  创建BookService接口和实现类

    l  创建BookDao接口和实现类

    l  将dao和service配置 xml文件

    l  使用api测试

    3.1.1   dao

    public interface BookDao {

      

       public void addBook();

     

    }

    public class BookDaoImpl implements BookDao {

     

       @Override

       public void addBook() {

          System.out.println("di  add book");

       }

     

    }

    3.1.2   service

    1 public interface BookService {
    2 
    3  
    4 
    5    public abstract void addBook();
    6 
    7  
    8 
    9 }
    IUserService
     1 public class BookServiceImpl implements BookService {
     2 
     3   
     4 
     5    // 方式1:之前,接口=实现类
     6 
     7 // private BookDao bookDao = new BookDaoImpl();
     8 
     9    // 方式2:接口 + setter
    10 
    11    private BookDao bookDao;
    12 
    13    public void setBookDao(BookDao bookDao) {
    14 
    15       this.bookDao = bookDao;
    16 
    17    }
    18 
    19   
    20 
    21    @Override
    22 
    23    public void addBook(){
    24 
    25       this.bookDao.addBook();
    26 
    27    }
    28 
    29  
    30 
    31 }
    UserServiceIplm

      

    3.2   配置文件

     1 <beans xmlns="http://www.springframework.org/schema/beans"
     2        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     3        xsi:schemaLocation="http://www.springframework.org/schema/beans 
     4                               http://www.springframework.org/schema/beans/spring-beans.xsd">
     5     <!-- 
     6     模拟spring执行过程
     7         创建service实例:BookService bookService = new BookServiceImpl()    IoC  <bean>
     8         创建dao实例:BookDao bookDao = new BookDaoImpl()            IoC
     9         将dao设置给service:bookService.setBookDao(bookDao);        DI   <property>
    10         
    11         <property> 用于进行属性注入
    12             name: bean的属性名,通过setter方法获得
    13                 setBookDao ##> BookDao  ##> bookDao
    14             ref :另一个bean的id值的引用
    15      -->
    16 
    17     <!-- 创建service -->
    18     <bean id="bookServiceId" class="com.itheima.b_di.BookServiceImpl">
    19         <property name="bookDao" ref="bookDaoId"></property>
    20     </bean>
    21     <!-- 创建dao实例 -->
    22     <bean id="bookDaoId" class="com.itheima.b_di.BookDaoImpl"></bean>
    23     
    24 
    25 </beans>
    applicationContext.xml

      

    3.3   测试

        @Test

        public void demo01(){

            //从spring容器获得

            String xmlPath = "com/itheima/b_di/beans.xml";

            ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);

            BookService bookService = (BookService) applicationContext.getBean("bookServiceId");

           

            bookService.addBook();

           

        }

    4       myeclipse schema xml提示

    l  步骤一:确定xsd文件位置

           spring-framework-3.2.0.RELEASEschemaeans

          

    l  步骤二:复制路径

          

    l  步骤三:搜索“xml catalog”

          

    l  步骤四:添加约束提示

          

    5  核心API

    l  api整体了解,之后不使用,在学习过程需要。

     

    l  BeanFactory :这是一个工厂,用于生成任意bean。

           采取延迟加载,第一次getBean时才会初始化Bean

    l  ApplicationContext:是BeanFactory的子接口,功能更强大。(国际化处理、事件传递、Bean自动装配、各

              种不同应用层的Context实现)。当配置文件被加载,就进行对象实例化。

           ClassPathXmlApplicationContext 用于加载classpath(类路径、src)下的xml

                  加载xml运行时位置 --> /WEB-INF/classes/...xml

           FileSystemXmlApplicationContext 用于加载指定盘符下的xml

                  加载xml运行时位置 --> /WEB-INF/...xml

                         通过java web ServletContext.getRealPath() 获得具体盘符

        @Test

        public void demo02(){

            //使用BeanFactory  --第一次条用getBean实例化

            String xmlPath = "com/itheima/b_di/beans.xml";

           

            BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource(xmlPath));

           

            BookService bookService = (BookService) beanFactory.getBean("bookServiceId");

           

            bookService.addBook();

           

        }

    6       装配Bean 基于XML

    6.1   实例化方式

    l  3种bean实例化方式:默认构造、静态工厂、实例工厂

    6.1.1   默认构造

    <bean id="" class="">  必须提供默认构造

    6.1.2   静态工厂

    l  常用与spring整合其他框架(工具)

    l  静态工厂:用于生成实例对象,所有的方法必须是static

    <bean id=""  class="工厂全限定类名"  factory-method="静态方法">

    6.1.2.1   工厂

    public class MyBeanFactory {

      

       /**

        * 创建实例

        * @return

        */

       public static UserService createService(){

          return new UserServiceImpl();

       }

    }

    6.1.2.2    spring配置

        <!-- 将静态工厂创建的实例交予spring

            class 确定静态工厂全限定类名

            factory-method 确定静态方法名

        -->

        <bean id="userServiceId" class="com.itheima.c_inject.b_static_factory.MyBeanFactory" factory-method="createService"></bean>

    6.1.3   实例工厂

    l  实例工厂:必须先有工厂实例对象,通过实例对象创建对象。提供所有的方法都是“非静态”的。

    6.1.3.1         工厂

    /**

     * 实例工厂,所有方法非静态

     *

     */

    public class MyBeanFactory {

      

       /**

        * 创建实例

        * @return

        */

       public UserService createService(){

          return new UserServiceImpl();

       }

     

    }

    6.1.3.2         spring配置

     

        <!-- 创建工厂实例 -->

        <bean id="myBeanFactoryId" class="com.itheima.c_inject.c_factory.MyBeanFactory"></bean>

        <!-- 获得userservice

            * factory-bean 确定工厂实例

            * factory-method 确定普通方法

        -->

        <bean id="userServiceId" factory-bean="myBeanFactoryId" factory-method="createService"></bean>

       

    6.2   Bean种类

    l  普通bean:之前操作的都是普通bean。<bean id="" class="A"> ,spring直接创建A实例,并返回

    l  FactoryBean:是一个特殊的bean,具有工厂生成对象能力,只能生成特定的对象。

           bean必须使用 FactoryBean接口,此接口提供方法 getObject() 用于获得特定bean。

           <bean id="" class="FB"> 先创建FB实例,使用调用getObject()方法,并返回方法的返回值

                  FB fb = new FB();

                  return fb.getObject();

    l  BeanFactory 和 FactoryBean 对比?

           BeanFactory:工厂,用于生成任意bean。

           FactoryBean:特殊bean,用于生成另一个特定的bean。例如:ProxyFactoryBean ,此工厂

               bean用于生产代理。<bean id="" class="....ProxyFactoryBean"> 获得代理对象实例。AOP使用

          

    6.3   作用域

    l  作用域:用于确定spring创建bean实例个数

          

    l  取值:

           singleton 单例,默认值

           prototype 多例,每执行一次getBean将获得一个实例。例如:struts整合spring,配置action多例。

    l  配置信息

    <bean id="" class=""  scope="">

     

    <bean id="userServiceId" class="com.itheima.d_scope.UserServiceImpl"

          scope="prototype" ></bean>

    6.4   生命周期

    6.4.1   初始化和销毁

    l  目标方法执行前后执行后,将进行初始化或销毁。

    <bean id="" class="" init-method="初始化方法名称"  destroy-method="销毁的方法名称">

    6.4.1.1   目标类

    public class UserServiceImpl implements UserService {

     

       @Override

       public void addUser() {

          System.out.println("e_lifecycle add user");

       }

      

       public void myInit(){

          System.out.println("初始化");

       }

       public void myDestroy(){

          System.out.println("销毁");

       }

     

    }

    6.4.1.2         spring配置

    <!-- 

          init-method 用于配置初始化方法,准备数据等

          destroy-method 用于配置销毁方法,清理资源等

       -->

       <bean id="userServiceId" class="com.itheima.e_lifecycle.UserServiceImpl"

          init-method="myInit" destroy-method="myDestroy" ></bean>

    6.4.1.3         测试

    @Test

        public void demo02() throws Exception{

            //spring 工厂

            String xmlPath = "com/itheima/e_lifecycle/beans.xml";

            ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);

            UserService userService = (UserService) applicationContext.getBean("userServiceId");

            userService.addUser();

           

            //要求:1.容器必须close,销毁方法执行; 2.必须是单例的(scope规定。)

    //      applicationContext.getClass().getMethod("close").invoke(applicationContext);

            // * 此方法接口中没有定义,实现类提供

            applicationContext.close();

           

        }

    6.4.2   BeanPostProcessor 后处理Bean

    l  spring 提供一种机制,只要实现此接口BeanPostProcessor,并将实现类提供给spring容器,spring容器将自动执行,在初始化方法前执行before(),在初始化方法后执行after() 。 配置<bean class="">

          

    l  Factory hook(勾子) that allows for custom modification of new bean instances, e.g. checking for marker interfaces or wrapping them with proxies.

    l  spring提供工厂勾子,用于修改实例对象,可以生成代理对象,是AOP底层。

    模拟

    A a =new A();

    a = B.before(a)                    --> 将a的实例对象传递给后处理bean,可以生成代理对象并返回。

    a.init();

    a = B.after(a);

    a.addUser();           //生成代理对象,目的在目标方法前后执行(例如:开启事务、提交事务)

    a.destroy()

    6.4.2.1         编写实现类

     1 public class MyBeanPostProcessor implements BeanPostProcessor {
     2 
     3  
     4 
     5     @Override
     6 
     7     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
     8 
     9         System.out.println("前方法 : " + beanName);
    10 
    11         return bean;
    12 
    13     }
    14 
    15  
    16 
    17     @Override
    18 
    19     public Object postProcessAfterInitialization(final Object bean, String beanName) throws BeansException {
    20 
    21         System.out.println("后方法 : " + beanName);
    22 
    23         // bean 目标对象
    24 
    25         // 生成 jdk 代理
    26 
    27         return Proxy.newProxyInstance(
    28 
    29                     MyBeanPostProcessor.class.getClassLoader(),
    30 
    31                     bean.getClass().getInterfaces(),
    32 
    33                     new InvocationHandler(){
    34 
    35                         @Override
    36 
    37                         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    38 
    39                            
    40 
    41                             System.out.println("------开启事务");
    42 
    43                            
    44 
    45                             //执行目标方法
    46 
    47                             Object obj = method.invoke(bean, args);
    48 
    49                            
    50 
    51                             System.out.println("------提交事务");
    52 
    53                             return obj;
    54 
    55                         }});
    56 
    57     }
    58 
    59 }
    后处理bean的初始化事物处理实现类


    6.4.2.2         配置
     

    <!-- 将后处理的实现类注册给spring -->

       <bean class="com.itheima.e_lifecycle.MyBeanPostProcessor"></bean>

    l  问题1:后处理bean作用某一个目标类,还是所有目标类?

             所有

    l  问题2:如何只作用一个?

             通过“参数2”beanName进行控制

    6.5   属性依赖注入

    l  依赖注入方式:手动装配 和 自动装配

    l  手动装配:一般进行配置信息都采用手动

           基于xml装配:构造方法、setter方法

           基于注解装配:

    l  自动装配:struts和spring 整合可以自动装配

           byType:按类型装配

           byName:按名称装配

           constructor构造装配,

           auto: 不确定装配。

    6.5.1   构造方法

    6.5.1.1         目标类

     1 public class User {
    
     5     private Integer uid;
     6 
     7     private String username;
     8 
     9     private Integer age;
    
    13     public User(Integer uid, String username) {
    14 
    15         super();
    16 
    17         this.uid = uid;
    18 
    19         this.username = username;
    20 
    21     }
    24 
    25     public User(String username, Integer age) {
    26 
    27         super();
    28 
    29         this.username = username;
    30 
    31         this.age = age;
    32 
    33     }


    6.5.1.2  (构造函数的) spring配置
     

     1 <!-- 构造方法注入 
     2         * <constructor-arg> 用于配置构造方法一个参数argument
     3             name :参数的名称
     4             value:设置普通数据
     5             ref:引用数据,一般是另一个bean id值
     6             
     7             index :参数的索引号,从0开始 。如果只有索引,匹配到了多个构造方法时,默认使用第一个。
     8             type :确定参数类型
     9         例如:使用名称name
    10             <constructor-arg name="username" value="jack"></constructor-arg>
    11             <constructor-arg name="age" value="18"></constructor-arg>
    12         例如2:【类型type 和  索引 index】
    13             <constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
    14             <constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
    15     -->
    16     <bean id="userId" class="com.itheima.f_xml.a_constructor.User" >
    17         <constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
    18         <constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
    19     </bean>
    applicationContext.xml

    6.5.2   setter方法

     1 <!-- setter方法注入
     2 
     3         * 普通数据
     4 
     5             <property name="" value="值">
     6 
     7             等效
     8 
     9             <property name="">
    10 
    11                 <value>值
    12 
    13         * 引用数据
    14 
    15             <property name="" ref="另一个bean">
    16 
    17             等效
    18 
    19             <property name="">
    20 
    21                 <ref bean="另一个bean"/>
    22 
    23    
    24 
    25     -->
    26 
    27     <bean id="personId" class="com.itheima.f_xml.b_setter.Person">
    28 
    29         <property name="pname" value="阳志"></property>
    30 
    31         <property name="age">
    32 
    33             <value>1234</value>
    34 
    35         </property>
    36 
    37        
    38 
    39         <property name="homeAddr" ref="homeAddrId"></property>
    40 
    41         <property name="companyAddr">
    42 
    43             <ref bean="companyAddrId"/>
    44 
    45         </property>
    46 
    47     </bean>
    48 
    49    
    50 
    51     <bean id="homeAddrId" class="com.itheima.f_xml.b_setter.Address">
    52 
    53         <property name="addr" value="阜南"></property>
    54 
    55         <property name="tel" value="911"></property>
    56 
    57     </bean>
    58 
    59     <bean id="companyAddrId" class="com.itheima.f_xml.b_setter.Address">
    60 
    61         <property name="addr" value="北京八宝山"></property>
    62 
    63         <property name="tel" value="120"></property>
    64 
    65     </bean>
    applicationContext.xml

     

    6.5.3   P命令空间[了解]

    l  对“setter方法注入”进行简化,替换<property name="属性名">,而是在

           <bean p:属性名="普通值"  p:属性名-ref="引用值">

    l  p命名空间使用前提,必须添加命名空间(复制第一行空间,改名)

          

        <bean id="personId" class="com.itheima.f_xml.c_p.Person"

            p:pname="禹太璞" p:age="22"

            p:homeAddr-ref="homeAddrId" p:companyAddr-ref="companyAddrId">

        </bean>

       

        <bean id="homeAddrId" class="com.itheima.f_xml.c_p.Address"

            p:addr="DG" p:tel="东莞">

        </bean>

        <bean id="companyAddrId" class="com.itheima.f_xml.c_p.Address"

            p:addr="DG" p:tel="岛国">

        </bean>

    6.5.4   SpEL[了解]

    l  对<property>进行统一编程,所有的内容都使用value

           <property name="" value="#{表达式}">

           #{123}、#{'jack'} : 数字、字符串

           #{beanId}      :另一个bean引用

           #{beanId.propName}     :操作数据

           #{beanId.toString()}     :执行方法

           #{T(类).字段|方法}      :静态方法或字段

        <!--

            <property name="cname" value="#{'jack'}"></property>

            <property name="cname" value="#{customerId.cname.toUpperCase()}"></property>

                通过另一个bean,获得属性,调用的方法

            <property name="cname" value="#{customerId.cname?.toUpperCase()}"></property>

                ?.  如果对象不为null,将调用方法

        -->

        <bean id="customerId" class="com.itheima.f_xml.d_spel.Customer" >

            <property name="cname" value="#{customerId.cname?.toUpperCase()}"></property>

            <property name="pi" value="#{T(java.lang.Math).PI}"></property>

        </bean>

          

    6.5.5   集合注入

     1 <!-- 
     2         集合的注入都是给<property>添加子标签
     3             数组:<array>
     4             List:<list>
     5             Set:<set>
     6             Map:<map> ,map存放k/v 键值对,使用<entry>描述
     7             Properties:<props>  <prop key=""></prop>  【】
     8             
     9         普通数据:<value>
    10         引用数据:<ref>
    11     -->
    12     <bean id="collDataId" class="com.itheima.f_xml.e_coll.CollData" >
    13         <property name="arrayData">
    14             <array>
    15                 <value>DS</value>
    16                 <value>DZD</value>
    17                 <value>屌丝</value>
    18                 <value>屌中屌</value>
    19             </array>
    20         </property>
    21         
    22         <property name="listData">
    23             <list>
    24                 <value>与天南</value>
    25                 <value>问小天</value>
    26                 <value>李煜</value>
    27                 <value>曾小贤</value>
    28             </list>
    29         </property>
    30         
    31         <property name="setData">
    32             <set>
    33                 <value>何以</value>
    34                 <value>笑声</value>
    35                 <value>默默</value>
    36             </set>
    37         </property>
    38         
    39         <property name="mapData">
    40             <map>
    41                 <entry key="jack" value="杰克"></entry>
    42                 <entry>
    43                     <key><value>rose</value></key>
    44                     <value>肉丝</value>
    45                 </entry>
    46             </map>
    47         </property>
    48         
    49         <property name="propsData">
    50             <props>
    51                 <prop key="高富帅"></prop>
    52                 <prop key="白富美"></prop>
    53                 <prop key="男屌丝"></prop>
    54             </props>
    55         </property>
    56     </bean>
    集合注入的配置文件代码

    7       装配Bean 基于注解

    l  注解:就是一个类,使用@注解名称

    l  开发中:使用注解 取代 xml配置文件。

    1. @Component取代<bean class="">

           @Component("id") 取代 <bean id="" class="">

    2.web开发,提供3个@Component注解衍生注解(功能一样)取代<bean class="">

           @Repository :dao层

           @Service:service层

           @Controller:web层

    3.依赖注入    ,给私有字段设置,也可以给setter方法设置

           普通值:@Value("")

           引用值:

                  方式1:按照【类型】注入

                         @Autowired

                  方式2:按照【名称】注入1

                         @Autowired

                         @Qualifier("名称")

                  方式3:按照【名称】注入2

                         @Resource("名称")

    4.生命周期

           初始化:@PostConstruct

           销毁:@PreDestroy

    5.作用域

           @Scope("prototype") 多例

    l  注解使用前提,添加命名空间,让spring扫描含有注解类

    <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:component-scan base-package="com.itheima.g_annotation.a_ioc"></context:component-scan>

    </beans>

  • 相关阅读:
    [Python Study Notes]进程信息(丁丁软件监控进程,http-post)
    [Python Study Notes]cpu信息
    [Python Study Notes]电池信息
    [Python Study Notes]内存信息
    [Python Study Notes]磁盘信息和IO性能
    [Python Study Notes]计算cpu使用率v0.1
    [Python Study Notes]计算cpu使用率
    [Python Study Notes]psutil模块
    [解决问题] E: 无法获得锁 /var/lib/dpkg/lock
    [Python Study Notes] python面试题总结
  • 原文地址:https://www.cnblogs.com/soficircle/p/7108405.html
Copyright © 2020-2023  润新知