②扫描

Spring 为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测。然后根据注解进行后续操作。

以后的实体类是不会交给ioc容器为管理的? ? ?所以不可能在每一个类上都加上注解? 不可能每一类都交给ioc管理所以不但要有注解还要扫描??

演示??com.atguigu.spring

2 .准备工作

① 新建spring_ioc_annotation?

②? 导入依赖

<dependencies>
    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.1</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

③? 创建三层架构?

控制层 com.atguigu.spring.controller.UserController

业务层：com.atguigu.spring.service.UserService? ? ?接口

? ? ? ? ? ? ? ?com.atguigu.spring.service.impl.UserServiceImpl? ?实现类?

持久层：com.atguigu.spring.dao.UserDao? ? 接口

? ? ? ? ? ? ? com.atguigu.spring.dao.impl.UserDaoImpl? ? 实现类

代码如下：

控制层 com.atguigu.spring.controller.UserController

package com.atguigu.spring.controller;

public class UserController {
    
}

业务层：com.atguigu.spring.service.UserService? ? ?接口

? ? ? ? ? ? ? ?com.atguigu.spring.service.impl.UserServiceImpl? ?实现类?

package com.atguigu.spring.service;

public interface UserService {
    
}

package com.atguigu.spring.service.impl;

import com.atguigu.spring.service.UserService;

public class UserServiceImpl  implements UserService {


}

持久层：com.atguigu.spring.dao.UserDao? ? 接口

? ? ? ? ? ? ? com.atguigu.spring.dao.impl.UserDaoImpl? ? 实现类

package com.atguigu.spring.dao;

public interface UserDao {
    
    
}

package com.atguigu.spring.dao.impl;

import com.atguigu.spring.dao.UserDao;

public class UserDaoImpl   implements UserDao  {


}

④? ?创建Spring配置文件 spring-ioc-annotation.xml

⑤? 测试类? ?IOCByAnnotationTest

package com.atguigu.spring.test;


import org.junit.Test;

public class IOCByAnnotationTest {

    @Test
    public  void  test(){
    }
}

3 .现在我们要做的事情

现在要做的事情就是通过注解来管理bean? 那我们有哪些注解呢？

我们现在要把一个类交给IOC来管理? 我们要用到以下四个注解

① 标识组件的常用注解

@Component ：将类标识为普通组件

组件：每一个bean都是IOC容器的组件? ?所以将类标识为普通组件就是加上这个注解并扫描之后，就可以把当前加上这个注解的类做为一个bean 被IOC容器管理?

@Controller ：将类标识为控制层组件

@Service ：将类标识为业务层组件

@Repository ：将类标识为持久层组件

问：以上四个注解有什么关系和区别？

通过查看源码我们得知， @Controller 、 @Service 、 @Repository 这三个注解只是在 @Component 注解

的基础上起了三个新的名字。

对于 Spring 使用 IOC 容器管理这些组件来说没有区别。所以 @Controller 、 @Service 、 @Repository 这

三个注解只是给开发人员看的，让我们能够便于分辨组件的作用。

注意：虽然它们本质上一样，但是为了代码的可读性，为了程序结构严谨我们肯定不能随便胡乱标记。

②? 接下来我们要把注解标记在我们刚才创建的三层架构上

代码如下：

控制层组件

package com.atguigu.spring.controller;

import org.springframework.stereotype.Controller;

@Controller
public class UserController {

}

业务层组件 UserServiceImpl

package com.atguigu.spring.service.impl;

import com.atguigu.spring.service.UserService;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl  implements UserService {


}

持久层组件 UserDaoImpl

package com.atguigu.spring.dao.impl;

import com.atguigu.spring.dao.UserDao;
import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl   implements UserDao  {


}

注意：注解不能加到接口? ?一定要加到实现类上??

因为加上注解的作用是:? 加上注解的类在IOC容器中配置了一个当前类型的bean? 一个bean的类型不能够是一个接口类型??

③? 接下去我们要在配置文件spring-ioc-annotation.xml里面进行扫描

为什么要扫描：

在类上加上注解要想让spring知道? 得要扫描? 要让spring知道哪些类加上了注解? 加了什么注解??

因为一层一层的包就是一层一层的目录? 所以我们主要扫描包就可以

    <!--扫描组件-->
   <context:component-scan base-package="com.atguigu.spring"></context:component-scan>

④? 接下来我们来进行测试一下

在理解一下注解+扫描的意思：

它可以将我们扫描的包下加上注解的这些类做为组件进行管理?

做为组件进行管理：在IOC容器中就有了当前加上这个注解的这个类所对应的bean对象

测试：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class IOCByAnnotationTest {

      /* @Component：将类标识为普通组件
       * @Controller：将类标识为控制层组件
       * @Service：将类标识为业务层组件
       * @Repository：将类标识为持久层组件*/

    @Test
    public  void  test(){
     ApplicationContext ioc =new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");

        UserController userController = ioc.getBean(UserController.class);
        System.out.println(userController);

        UserService userService = ioc.getBean(UserService.class);
        System.out.println(userService);

        UserDao userDao = ioc.getBean(UserDao.class);
        System.out.println(userDao);


    }
}

??二. 标记与扫描(基于注解管理bean之扫描组件)

问题：

以后在ssm整合的时候? spring 和springmvc 是放在一块使用的? 而springmvc要扫描的是我们的控制层,spring要扫描的是除控制层以外的所有组件??? 这个时候应该怎么办？
如果springmvc 把控制层给扫描了? spring也把控制层扫描了? 这个时候一个组件就被扫描多次??

我们现在要做的是 springmvc 扫描控制层然后spring把其他的层给扫描了?

就要用到排除扫描标签具体如下

1 .排除扫描

第一种??annotation：根据注解的类型进行排除，expression需要设置排除的注解的全类名(用得多)

<?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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--扫描组件-->
   <context:component-scan base-package="com.atguigu.spring">
       
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
       
   </context:component-scan>

</beans>

测试：

    @Test
    public  void  test(){
     ApplicationContext ioc =new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");

        UserController userController = ioc.getBean(UserController.class);
        System.out.println(userController);

        UserService userService = ioc.getBean(UserService.class);
        System.out.println(userService);

        UserDao userDao = ioc.getBean(UserDao.class);
        System.out.println(userDao);


    }
}

虽然在控制层加了但是因为排除了所以并没有扫描到? ?但是不影响对其他层的扫描如下测试

    @Test
    public  void  test(){
     ApplicationContext ioc =new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");

       /* UserController userController = ioc.getBean(UserController.class);
        System.out.println(userController);*/

        UserService userService = ioc.getBean(UserService.class);
        System.out.println(userService);

        UserDao userDao = ioc.getBean(UserDao.class);
        System.out.println(userDao);
    }

全类名的复制方法;

要把控制层的扫描给排除掉? 所以我们找到控制层找到注解点击右键? 把全类名放过来? 这个时候就不扫描控制层了?

??第二种：assignable：根据类的类型进行排除，expression需要设置排除的类的全类名（用得少）

<?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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--扫描组件-->
   <context:component-scan base-package="com.atguigu.spring">

   <!-- <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>-->
       <context:exclude-filter type="assignable" expression="com.atguigu.spring.controller.UserController"/>
       
   </context:component-scan>

</beans>

测试：

public class IOCByAnnotationTest {

      /* @Component：将类标识为普通组件
       * @Controller：将类标识为控制层组件
       * @Service：将类标识为业务层组件
       * @Repository：将类标识为持久层组件*/

    @Test
    public  void  test(){
     ApplicationContext ioc =new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");
     
       UserController userController = ioc.getBean(UserController.class);
        System.out.println(userController);

        UserService userService = ioc.getBean(UserService.class);
        System.out.println(userService);

        UserDao userDao = ioc.getBean(UserDao.class);
        System.out.println(userDao);
    }
}

全类名的复制方法

我们找到控制层找到UserController类?点击右键? 把全类名放过来? 这个时候在扫描包的时候就会把UserController类给排除?

?注意：以后用得比较多的是根据注解的方式排除因为以后要用到这个标签<context:exclude-filter type=""的时候是在ssm整合的时候? ?springmvc要扫描的是控制层? spring要扫描的是除控制层以外的其他组件?

二种方法整合一起并解释：

<?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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--    context:exclude-filter：排除扫描
        type：设置排除扫描的方式
        type="annotation|assignable"
        annotation：根据注解的类型进行排除，expression需要设置排除的注解的全类名
        assignable：根据类的类型进行排除，expression需要设置排除的类的全类名-->
    <!--扫描组件-->
   <context:component-scan base-package="com.atguigu.spring">

   <!-- <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>-->
       <context:exclude-filter type="assignable" expression="com.atguigu.spring.controller.UserController"/>
       
   </context:component-scan>

</beans>

总结：

<!--    context:exclude-filter：排除扫描
    type：设置排除扫描的方式
    type="annotation|assignable"
    annotation：根据注解的类型进行排除，expression需要设置排除的注解的全类名
    assignable：根据类的类型进行排除，expression需要设置排除的类的全类名-->

2 .包含扫描? ?只扫描

<?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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--
        context:exclude-filter：排除扫描
        type：设置排除扫描的方式
        type="annotation|assignable"
        annotation：根据注解的类型进行排除，expression需要设置排除的注解的全类名
        assignable：根据类的类型进行排除，expression需要设置排除的类的全类名

        context:include-filter：包含扫描  只扫描
        注意：需要在context:component-scan标签中设置use-default-filters="false"
        use-default-filters="true"（默认），所设置的包下所有的类都需要扫描，此时可以使用排除扫描
        use-default-filters="false"，所设置的包下所有的类都不需要扫描，此时可以使用包含扫描
    -->
    
    
    
    <!--扫描组件-->
   <context:component-scan base-package="com.atguigu.spring" >

   <!-- <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>-->
      <!-- <context:exclude-filter type="assignable" expression="com.atguigu.spring.controller.UserController"/>-->
       <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>

   </context:component-scan>

</beans>

测试：

public class IOCByAnnotationTest {

      /* @Component：将类标识为普通组件
       * @Controller：将类标识为控制层组件
       * @Service：将类标识为业务层组件
       * @Repository：将类标识为持久层组件*/

    @Test
    public  void  test(){
     ApplicationContext ioc =new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");

       UserController userController = ioc.getBean(UserController.class);
        System.out.println(userController);

        UserService userService = ioc.getBean(UserService.class);
        System.out.println(userService);

        UserDao userDao = ioc.getBean(UserDao.class);
        System.out.println(userDao);
    }
}

测试结果发现都可以扫描到

修正如下：

<?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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--
        context:exclude-filter：排除扫描  
        type：设置排除扫描的方式
        type="annotation|assignable"
        annotation：根据注解的类型进行排除，expression需要设置排除的注解的全类名
        assignable：根据类的类型进行排除，expression需要设置排除的类的全类名

        context:include-filter：包含扫描   只扫描
        注意：需要在context:component-scan标签中设置use-default-filters="false"
        use-default-filters="true"（默认），所设置的包下所有的类都需要扫描，此时可以使用排除扫描
        use-default-filters="false"，所设置的包下所有的类都不需要扫描，此时可以使用包含扫描
    -->
    
    
    
    <!--扫描组件-->
   <context:component-scan base-package="com.atguigu.spring" use-default-filters="false">

   <!-- <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>-->
      <!-- <context:exclude-filter type="assignable" expression="com.atguigu.spring.controller.UserController"/>-->
       <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>

   </context:component-scan>

</beans>

?测试：

public class IOCByAnnotationTest {

      /* @Component：将类标识为普通组件
       * @Controller：将类标识为控制层组件
       * @Service：将类标识为业务层组件
       * @Repository：将类标识为持久层组件*/

    @Test
    public  void  test(){
     ApplicationContext ioc =new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");

       UserController userController = ioc.getBean(UserController.class);
        System.out.println(userController);

        UserService userService = ioc.getBean(UserService.class);
        System.out.println(userService);

        UserDao userDao = ioc.getBean(UserDao.class);
        System.out.println(userDao);
    }
}

总结：

context:include-filter：包含扫描
注意：需要在context:component-scan标签中设置use-default-filters="false"
use-default-filters="true"（默认），所设置的包下所有的类都需要扫描，此时可以使用排除扫描
use-default-filters="false"，所设置的包下所有的类都不需要扫描，此时可以使用包含扫描

?二种方法全部总结：

<!--
    context:exclude-filter：排除扫描
    type：设置排除扫描的方式
    type="annotation|assignable"
    annotation：根据注解的类型进行排除，expression需要设置排除的注解的全类名
    assignable：根据类的类型进行排除，expression需要设置排除的类的全类名

    context:include-filter：包含扫描
    注意：需要在context:component-scan标签中设置use-default-filters="false"
    use-default-filters="true"（默认），所设置的包下所有的类都需要扫描，此时可以使用排除扫描
    use-default-filters="false"，所设置的包下所有的类都不需要扫描，此时可以使用包含扫描
-->

?我们以后排除扫描用得比较多? 包含扫描用得比较少因为麻烦

平常用的话只要下如下就可以

    <!--扫描组件-->

       <context:component-scan base-package="com.atguigu.spring"></context:component-scan>

<?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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--
        context:exclude-filter：排除扫描
        type：设置排除扫描的方式
        type="annotation|assignable"
        annotation：根据注解的类型进行排除，expression需要设置排除的注解的全类名
        assignable：根据类的类型进行排除，expression需要设置排除的类的全类名

        context:include-filter：包含扫描
        注意：需要在context:component-scan标签中设置use-default-filters="false"
        use-default-filters="true"（默认），所设置的包下所有的类都需要扫描，此时可以使用排除扫描
        use-default-filters="false"，所设置的包下所有的类都不需要扫描，此时可以使用包含扫描
    -->



    <!--扫描组件-->

       <context:component-scan base-package="com.atguigu.spring"></context:component-scan>

<!--   <context:component-scan base-package="com.atguigu.spring" use-default-filters="false">

   &lt;!&ndash; <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>&ndash;&gt;
      &lt;!&ndash; <context:exclude-filter type="assignable" expression="com.atguigu.spring.controller.UserController"/>&ndash;&gt;
       <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>

   </context:component-scan>-->

</beans>

三. 标记与扫描(基于注解管理bean之bean的id)

在我们使用 XML 方式管理 bean 的时候，每个 bean 都有一个唯一标识，便于在其他地方引用。现在使用注解后，每个组件仍然应该有一个唯一标识。

默认情况

类名首字母小写就是 bean 的 id 。例如： UserController 类对应的 bean 的 id 就是 userController 。

自定义 bean 的 id

可通过标识组件的注解的 value 属性设置自定义的 bean 的 id

@Service("userService")// 默认为 userServiceImpl public class UserServiceImpl implements

UserService {}

复习：

注解所标识的类交给IOC管理：

注解标识的类经过扫描之后在IOC容器中自动去配置一个相对应的bean?

新知识：

问题：我们知道bean 都是有id的? 通过注解+扫描的id是啥呢？

答案：通过注解+扫描所配置的bean的id，默认值为类的小驼峰，即类名的首字母为小写的结果

验证：

IOCByAnnotationTest

public class IOCByAnnotationTest {

      /* @Component：将类标识为普通组件
       * @Controller：将类标识为控制层组件
       * @Service：将类标识为业务层组件
       * @Repository：将类标识为持久层组件*/

    @Test
    public  void  test(){
     ApplicationContext ioc =new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");

       UserController userController = ioc.getBean("userController",UserController.class);
        System.out.println(userController);

        UserService userService = ioc.getBean("userServiceImpl",UserService.class);
        System.out.println(userService);

        UserDao userDao = ioc.getBean("userDaoImpl",UserDao.class);
        System.out.println(userDao);
    }
}

?自定义bean的id?

可以通过标识组件的注解的value属性值设置bean的自定义的id

UserController

package com.atguigu.spring.controller;

import org.springframework.stereotype.Controller;

@Controller("controller")
public class UserController {

}

public class IOCByAnnotationTest {

      /* @Component：将类标识为普通组件
       * @Controller：将类标识为控制层组件
       * @Service：将类标识为业务层组件
       * @Repository：将类标识为持久层组件*/

    @Test
    public  void  test(){
     ApplicationContext ioc =new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");

       UserController userController = ioc.getBean("controller",UserController.class);
        System.out.println(userController);

        UserService userService = ioc.getBean("userServiceImpl",UserService.class);
        System.out.println(userService);

        UserDao userDao = ioc.getBean("userDaoImpl",UserDao.class);
        System.out.println(userDao);
    }
}

springmvc文件上传解析器? 就是根据id来获取的?

其他的地方一般用到的都是根据类型来获取?

? ? ? ? ? ? ? ? ?

[Java知识库](续)SSM整合之spring笔记(IOC 基于注解管理bean之注解和扫描，扫描组件，bean的id)（P087—P090）

基于注解管理bean

?一. 实验一：标记与扫描(基于注解管理bean之注解和扫描)

1 .注解与扫描的概念

①注解

②扫描

2 .准备工作

① 新建spring_ioc_annotation?

②? 导入依赖

③? 创建三层架构?

④? ?创建Spring配置文件 spring-ioc-annotation.xml

⑤? 测试类? ?IOCByAnnotationTest

3 .现在我们要做的事情

① 标识组件的常用注解

②? 接下来我们要把注解标记在我们刚才创建的三层架构上

③? 接下去我们要在配置文件spring-ioc-annotation.xml里面进行扫描

④? 接下来我们来进行测试一下

??二. 标记与扫描(基于注解管理bean之扫描组件)

1 .排除扫描

2 .包含扫描? ?只扫描

三. 标记与扫描(基于注解管理bean之bean的id)

[Java知识库](续)SSM整合之spring笔记(IOC 基于注解管理bean之注解和扫描，扫描组件，bean的id)（P087—P090）

基于注解管理bean

?一. 实验一：标记与扫描(基于注解管理bean之注解和扫描)

1 .注解与扫描的概念

①注解

②扫描

2 .准备工作

① 新建spring_ioc_annotation?

②? 导入依赖

③? 创建三层架构?

④? ?创建Spring配置文件 spring-ioc-annotation.xml

⑤? 测试类? ?IOCByAnnotationTest

3 .现在我们要做的事情

① 标识组件的常用注解

②? 接下来我们要把注解标记在我们刚才创建的三层架构上

③? 接下去 我们要在配置文件spring-ioc-annotation.xml里面进行扫描

④? 接下来我们来进行测试一下

??二. 标记与扫描(基于注解管理bean之扫描组件)

1 .排除扫描

2 .包含扫描? ?只扫描

三. 标记与扫描(基于注解管理bean之bean的id)

③? 接下去我们要在配置文件spring-ioc-annotation.xml里面进行扫描