spring介绍与ioc控制反转(一)【SSM框架】

spring思维导图
spring介绍和ioc控制反转(一)
spring框架aop详细(二)
spring框架结合mybatis(三)
spring框架事务处理(四)

一.spring介绍

spring全家桶：spring ， springmvc ，spring boot , spring cloud

spring: 出现是在2002左右，解决企业开发的难度。减轻对项目模块之间的管理，
类和类之间的管理， 帮助开发人员创建对象，管理对象之间的关系。
spring核心技术 ioc ， aop 。能实现模块之间，类之间的解耦合。

依赖：classa中使用classb的属性或者方法， 叫做classa依赖classb

---

2.框架怎么学
1）知道框架能做什么， mybatis–访问数据库， 对表中的数据执行增删改查。
2）框架的语法， 框架要完成一个功能，需要一定的步骤支持的，
3）框架的内部实现， 框架内部怎么做。 原理是什么。
4）通过学习，可以实现一个框架。

二.spring的第一个核心功能 ioc

IoC (Inversion of Control) : 控制反转， 是一个理论，概念，思想。
描述的：把对象的创建，赋值，管理工作都交给代码之外的容器实现， 也就是对象的创建是有其它外部资源完成。

控制： 创建对象，对象的属性赋值，对象之间的关系管理。
反转： 把原来的开发人员管理，创建对象的权限转移给代码之外的容器实现。 由容器代替开发人员管理对象。创建对象，给属性赋值。

正转：由开发人员在代码中，使用new 构造方法创建对象， 开发人员主动管理对象。
public static void main(String args[]){
Student student = new Student(); // 在代码中， 创建对象。–正转。
}

容器：是一个服务器软件， 一个框架（spring）

为什么要使用 ioc ： 目的就是减少对代码的改动， 也能实现不同的功能。 实现解耦合。

2.1 java中创建对象有哪些方式：

• 构造方法 ， new Student（）
• 反射
• 序列化
• 克隆
• ioc ：容器创建对象
• 动态代理

2.2 ioc的体现：

servlet

1. 创建类继承HttpServelt
2. 在web.xml 注册servlet ， 使用

<servlet-name> myservlet </servlet-name>
<servelt-class>com.tx.controller.MyServlet1</servlet-class>

4. 没有创建 Servlet对象， 没有 MyServlet myservlet = new MyServlet()
5. Servlet 是Tomcat服务器它能你创建的。 Tomcat也称为容器
   Tomcat作为容器：里面存放的有Servlet对象， Listener ， Filter对象

2.3.IoC的技术实现 ，

2.3.1 DI 是ioc的技术实现

DI（Dependency Injection） :依赖注入， 只需要在程序中提供要使用的对象名称就可以， 至于对象如何在容器中创建，赋值，查找都由容器内部实现。

spring是使用的di实现了ioc的功能， spring底层创建对象，使用的是反射机制。
spring是一个容器，管理对象，给属性赋值， 底层是反射创建对象。

Spring 容器是一个超级大工厂，负责创建、管理所有的 Java 对象，这些 Java 对象被称
为 Bean。Spring 容器管理着容器中 Bean 之间的依赖关系，Spring 使用“依赖注入”的方式
来管理 Bean 之间的依赖关系。使用 IoC 实现对象之间的解耦和。

resources.bean.xml文件
   <!--告诉spring创建对象
        声明bean，就是告诉spring要创建某个类的对象
        id:对象的自定义名称，唯一值。spring通过这个名称找到对象
        class:类的全限定名称（不能是接口，因为spring是反射机制创建对象，必须使用类）

        spring就是完成 SomeService someService = new SomeServiceImpl();
        spring是把创建好的对象放入map中，spring框架有一个map存放的对象的。
            springmap.put(id的值，对象);
            例如： springMap.put("someService",new SomeServiceImpl());

         一个bean标签声明一个对象。
    -->
    <bean id="someService" class="com.tx.service.impl.SomeServiceimpl"></bean>

    <bean id="someService1" class="com.tx.service.impl.SomeServiceimpl" scope="prototype" ></bean>

    <!--spring能创建一个非自定义类的对象吗，创建一个存在的某个类-->
    <bean id="mydate" class="java.util.Date"></bean>
</beans>

<!--
    spring的配置文件
    1.beans：是跟标签，spring把java对象变成bean。
    2.spring-beans.xsd 是约束文件，和mybatis指定 dtd是一样的。
-->

   /**
     * spring默认创建对象的时间：在创建spring的容器时,会创建配置文件中的所有对象
     * spring创建对象：默认调用的是无参构造方法
     * */
   public void test02(){
        //使用spring容器创建的对象
        //1.指定spring配置文件的名称
        String config = "beans.xml";
        //2.创建表示spring容器的对象，ApplicationContext
        //ApplicationContext就是表示spring容器，通过容器获取对象了
        //ClassPathXmlApplicationContext:表示从类路径中加载spring的配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        //从容器中获取某个对象，你要调用对象的方法
        //getBean("配置文件中的bean的id值")
        SomeService service = (SomeService) ac.getBean("someService");
        //使用spring创建对象
        service.doSome();

		//使用spring提供的方法，获取容器中定义的对象数量
		int nums = ac.getBeanDefinitionCount();
		System.out.println("容器中有多少个对象："+nums);//容器中有多少个对象：1
    }

2.3.2 基于xml的DI

2.1注入分类

1.set注入（设值注入） ：spring调用类的set方法， 你可以在set方法中完成属性赋值

1. 简单类型的set注入

<bean id="xx" class="yyy">
   <property name="属性名字" value="此属性的值"/>
   一个property只能给一个属性赋值
   <property....>
</bean>

2. 引用类型的set注入 ： spring调用类的set方法

<bean id="xxx" class="yyy">
	<property name="属性名称" ref="bean的id(对象的名称)" />
</bean>

<bean id="myStudent" class="com.tx.ba02.Student" >
    <property name="name" value="李四" />
    <property name="age" value="26" />
    <!--引用类型-->
    <property name="school" ref="mySchool" /><!--setSchool(mySchool)-->
</bean>

2.构造注入（理解）

<bean id="myStudent" class="com.tx.ba02.Student" >
  <constructor-arg name="myage" value="22"/>
  <constructor-arg name="myname" value="李四"/>
  <constructor-arg name="myXueXiao" ref="mySchool"/>
</bean>

2.2引用类型属性自动注入

1.byName(按名称注入) : java类中引用类型的属性名和spring容器中(配置文件)< bean>的id名称一样，
------------------------------------且数据类型是一致的，这样的容器中的bean，spring能够赋值给引用类型。
语法：

 <!--byName-->
    <bean id="myStudent" class="com.tx.ba04.Student"  autowire="byName">
        <property name="name" value="李四" />
        <property name="age" value="26" />
        <!--引用类型-->
        <!--<property name="school" ref="mySchool" />-->
    </bean>
    <!--声明School对象-->
    <bean id="school" class="com.tx.ba04.School">
        <property name="name" value="清华大学"/>
        <property name="address" value="北京的海淀区" />
    </bean>

2.byType(按类型注入) ： java类中引用类型的数据类型和spring容器中（配置文件< bean>的class属性
----------------------------------是同源关系的，这样的bean能够赋值给引用类型
同源就是一类的意思：

1. java类中引用类型的数据类型和bean的class的值是一样的。
2. java类中引用类型的数据类型和bean的class的值父子类关系的。
3. java类中引用类型的数据类型和bean的class的值接口和实现类关系的
   语法：

<!--byType-->
<bean id="myStudent" class="com.tx.ba05.Student"  autowire="byType">
    <property name="name" value="张飒" />
    <property name="age" value="26" />
    <!--引用类型-->
    <!--<property name="school" ref="mySchool" />-->
</bean>

<!--声明School对象-->
<bean id="mySchool" class="com.tx.ba05.School">
    <property name="name" value="人民大学"/>
    <property name="address" value="北京的海淀区" />
</bean>

2.3 为应用指定多个 Spring 配置文件

ba06/spring-total.xml
   <!--
         包含关系的配置文件：
         spring-total表示主配置文件 ： 包含其他的配置文件的，主配置文件一般是不定义对象的。
         语法：<import resource="其他配置文件的路径" />
         关键字："classpath:" 表示类路径（class文件所在的目录），
               在spring的配置文件中要指定其他文件的位置， 需要使用classpath，告诉spring到哪去加载读取文件。
    -->

    <!--加载的是文件列表-->
    <!--
    <import resource="classpath:ba06/spring-school.xml" />
    <import resource="classpath:ba06/spring-student.xml" />
    -->

    <!--
       在包含关系的配置文件中，可以通配符（*：表示任意字符）
       注意： 主的配置文件名称不能包含在通配符的范围内（不能叫做spring-total.xml）
    -->
    <import resource="classpath:ba06/spring-*.xml" />
</beans>

public void test01(){
	//加载的是总的文件
	String config = "ba06/spring-total.xml";
	ApplicationContext ac = new ClassPathXmlApplicationContext(config);
	//从容器中获取Student对象
	Student myStudent = (Student) ac.getBean("myStudent");
	System.out.println("student对象="+myStudent);
}

2.3.3 基于注解的 DI

使用注解的步骤：
1.加入maven的依赖 spring-context ，在你加入spring-context的同时， 间接加入spring-aop的依赖。使用注解必须使用spring-aop依赖

<!--spring依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>

2.在类中加入spring的注解（多个不同功能的注解）

/**
 * @Component: 创建对象的， 等同于<bean>的功能
 *     属性：value 就是对象的名称，也就是bean的id值，
 *          value的值是唯一的，创建的对象在整个spring容器中就一个
 *     位置：在类的上面
 *
 *  @Component(value = "myStudent")等同于
 *   <bean id="myStudent" class="com.tx.ba01.Student" />
 *
 *  spring中和@Component功能一致，创建对象的注解还有：
 *  1.@Repository（用在持久层类的上面） : 放在dao的实现类上面，
 *               表示创建dao对象，dao对象是能访问数据库的。
 *  2.@Service(用在业务层类的上面)：放在service的实现类上面，
 *              创建service对象，service对象是做业务处理，可以有事务等功能的。
 *  3.@Controller(用在控制器的上面)：放在控制器（处理器）类的上面，创建控制器对象的，
 *              控制器对象，能够接受用户提交的参数，显示请求的处理结果。
 *  以上三个注解的使用语法和@Component一样的。 都能创建对象，但是这三个注解还有额外的功能。
 *  @Repository，@Service，@Controller是给项目的对象分层的。
 *
 */
//使用value属性，指定对象名称
//@Component(value = "myStudent")
//省略value
@Component("myStudent")
//不指定对象名称，由spring提供默认名称: 类名的首字母小写，这里也就是:student;
//@Component
public class Student {}

3.在spring的配置文件中，加入一个组件扫描器的标签，说明注解在你的项目中的位置

  <!--声明组件扫描器(component-scan),组件就是java对象
        base-package：指定注解在你的项目中的包名。
        component-scan工作方式： spring会扫描遍历base-package指定的包，
           把包中和子包中的所有类，找到类中的注解，按照注解的功能创建对象，或给属性赋值。

       加入了component-scan标签，配置文件的变化：
        1.加入一个新的约束文件spring-context.xsd
        2.给这个新的约束文件起个命名空间的名称
    -->
   <!--指定多个包的三种方式-->
    <!--第一种方式：使用多次组件扫描器，指定不同的包-->
    <context:component-scan base-package="com.tx.ba01"/>
    <context:component-scan base-package="com.tx.ba02"/>

    <!--第二种方式：使用分隔符（;或,）分隔多个包名-->
    <context:component-scan base-package="com.tx.ba01;com.tx.ba02" />

    <!--第三种方式：指定父包-->
    <context:component-scan base-package="com.tx" />

• 学习的注解：
  1.@Component
  2.@Respotory
  3.@Service
  4.@Controller
  5.@Value

   /**
   * @Value: 简单类型的属性赋值
   *   属性： value 是String类型的，表示简单类型的属性值
   *   位置： 1.在属性定义的上面，无需set方法，推荐使用。
   *         2.在set方法的上面
   */
  @Value("李四" )
  private String name;
  private Integer age;
  
  /**
   * 引用类型
   * @Autowired: spring框架提供的注解，实现引用类型的赋值。
   * spring中通过注解给引用类型赋值，使用的是自动注入原理 ，支持byName, byType
   * @Autowired:默认使用的是byType自动注入。
   *
   * 属性：required ，是一个boolean类型的，默认true
   *       required=true：表示引用类型赋值失败，程序报错，并终止执行。
   *       required=false：引用类型如果赋值失败， 程序正常执行，引用类型是null
   * 
   *  位置：1）在属性定义的上面，无需set方法， 推荐使用
   *       2）在set方法的上面
   *  如果要使用byName方式，需要做的是：
   *  1.在属性上面加入@Autowired
   *  2.在属性上面加入@Qualifier(value="bean的id") ：表示使用指定名称的bean完成赋值。
   */
  //默认byType自动注入
  @Autowired
  private School school;
  //byName自动注入
  @Autowired
  @Qualifier("mySchool")
  private School school;	
  

  6.@Autowired
  7.@Resource

  /**
   * 引用类型
   * @Resource: 来自jdk中的注解，spring框架提供了对这个注解的功能支持，可以使用它给引用类型赋值
   *            使用的也是自动注入原理，支持byName， byType .默认是byName
   *  位置： 1.在属性定义的上面，无需set方法，推荐使用。
   *        2.在set方法的上面
   * @Resource只使用byName方式，需要增加一个属性 name
   * name的值是bean的id（名称）
   */
  //默认是byName： 先使用byName自动注入，如果byName赋值失败，再使用byType
  @Resource
  private School school;
  

@Value搭配配置文件

 <!--加载属性配置文件-->
    <context:property-placeholder location="classpath:test.properties" />

@Value("${myage}")
private String name;

用户处理请求：
用户form ,参数name ，age-----Servlet(接收请求name，age)—Service类（处理name，age操作）—dao类（访问数据库的）—mysql