Spring网课第二天

框架怎么学？

框架是一个别人写好的软件

1. 知道框架能干什么 MyBatis --访问数据库，对表中数据增删改查
2. 框架的使用语法（别人制定的语法）
3. 框架的内部实现
4. 尝试模拟框架实现

---

Spring核心功能1 IoC（控制反转）

  控制反转（ioc ，Inversion of Cound），是一个概念，是一种思想。

指将传统上由程序代码直接操控的对象调用权交给容器，由容器来实现对象的装配和管理，控制翻转就是对对象控制权的转移，由程序代码本身反转到了外部容器，通过容器进行对象的创建，属性赋值，依赖管理等

IoC的实现方式多种多样，当前比较流行的实现方式是依赖注入。应用范围广泛。

• 依赖： classA类中含有classB类的实例，在classA中调用classB方法完成功能，即classA对classB有依赖。
• 依赖注入： DI（Dependency Injection），程序代码不做定位查询，这些工作由容器自行完成，依赖注入是指程序运行过程中，若需要调用另一个对象协助时，无需在代码中创建被调用者，而是依赖外部容器，由外部容器创建后传递给程序。

【Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对象之间依赖关系的管理】

• Spring框架使用依赖注入实现IoC： Spring容器是一个超级大工厂，负责创建、管理所有的java对象，这些java对象被称作Bean，Spring容器管理容器中Bean之间的依赖关系，Spring使用“依赖注入”的方式来管理Bean之间的依赖关系。使用IoC实现对象之间的解耦合（更少的改动实现更多的功能）。

---

java中创建对象的方式：
1构造方法： new Student（）
2反射
3序列化
4克隆
5IoC：容器创建对象
6动态代理

IoC的体现：

Servlet
1：创建类继承HttpServlet

2：在web.xml中注册Servlet(xml配置)

3：没有创建过Servlet对象，直接可地址访问

（没有new MyServlet（）但是可以直接用）

4：Servlet对象是Tomcat服务器帮我们创建的，Tomcat也是容器，里面存放的是Servlet对象，Listener，Filter对象。

IoC的技术实现
DI依赖注入是IoC的技术实现，程序中只需要提供要使用的对象名称即可，对象如何在容器中创建、赋值、查找都由容器内部实现。

IOC过程案例

IoC过程
	第一步：xml配置文件，配置创建的对象
	<bean id = "dao" class = "com.study.leleWantStudyJava.UserDao"></bean>

	第二步：有service类和dao类，创建工厂类
	class UserFactory{
		public static UserDao getDao（）{
		String classValue =  class属性值;//xml解析
		Class clazz = Class.forName(classValue);//通过反射创建对象
		return （UserDao）clazz.newInstance();
	}

}

---

创建第一个项目

先创建一个空工程：

这是项目本次的模板：

点击加号新建一个项目，之后的选项看上图

第一次构建项目很慢。。。一堆东西下载呢？（pom文件会自己改。。。厉害了！）

项目结构

项目ch1
	*src
		**main
			***java
				****course01
			***(创建一个resources目录，就暂时够用了，alt+insert，选择Directory)
			(右键指定这个目录是一个ResourceRoot(make directory as->))
	*test
		**java
	*ch1.iml
	*pom.xml(一个Maven项目中一定会有一个pom文件)

对初始的pom进行分析

<?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>course01</groupId>
  <artifactId>ch1</artifactId>
  <version>1.0-SNAPSHOT</version>
//生成站点时用到的的东西
  <name>ch1</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
//版本，教学视频里面的是改成1.8
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
//单元测试的依赖
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
//生命周期插件，暂时不需要可以删掉
  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

spring ioc,由Spring来创建对象，实现步骤：
1 创建Maven项目
2 加入Spring的Maven依赖，版本5.2.5
Junit依赖（方便单元测试）
3 创建类（接口和它的实现类）同没有实现框架一样，创建一个普通的类
4 类似Servlet，需要告知容器要创建怎样的一个对象。此处要创建一个Spring的配置文件（声明的类由容器来创建和管理实例对象）
alt+insert，打开新建，直接打xml搜索，下面那个箭头点进去有SpringConfig，新建即可
成功————————————————————————————成功

5 测试Spring创建的对象。

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
       //xsd是另一种配置文件的扩展名
声明bean，就是告诉Spring要创建某个类的对象
	id：对象的自定义名称，id值必须保持唯一。Spring通过这个名称找到对象
	class：类的全限定名称（不能是接口，因为Spring是反射机制创建对象，必须使用类）
	
	Spring完成创建对象，放在map中以便后续引用。
	【SpringMap.put(id,对象)】

 <bean id="someService" class="course01.impl.SomeServiceImpl"/>
 声明一个id为someService的实例
</beans>//根标签

Spring的配置文件：
1 Beans：根标签，在Spring中，java对象被称为bean。
2 Spring-beans.xsd是约束文件,和MyBatis指定 dtd 是一样的。
3

重点： class：类的全限定名称（不能是接口，因为Spring是反射机制创建对象，必须使用类）

从容器里面获取对象实例：

package course01;

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

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        //指定Spring容器创建的对象
        //1指定Spring配置文件的名称
        String config = "beans.xml";
        //2创建表示Spring容器的对象，ApplicationContext
        //ApplicationContext就表示Spring容器。通过容器对象就能获取创建好的对象了
        ApplicationContext  applicationContext= new ClassPathXmlApplicationContext(config);
        //一般用这个，同级还有个FileSystemXmlApplicationContext，用来获取磁盘中的配置文件
        //ClassPathXmlApplicationContext：表示从类路径中加载Spring的配置文件。
        //类路径就是项目配置好以后的类路径
        //getBean（配置文件中Bean的id值）
        SomeService service = (SomeService)applicationContext.getBean("someService");

        //使用获取到的对象

        service.doSome();
    }
}

Bean本体

package course01.impl;

import course01.SomeService;

public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome() {
        System.out.println("执行了SomeServiceImpl的doSome()");
    }
}

IOC(接口)

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
Spring提供IOC容器两种实现方式：（两套接口规范）、

1）BeanFactory ：Spring内置的基本实现（一般不提供给开发者使用）

加载配置文件的时候不会创建对象。在获取对象（使用）的时候才去创建对象

2）ApplicationContext：BeanFactory的子接口，提供了更为丰富的功能。（开发人员使用）

加载配置文件的时候就会将对象根据配置文件进行创建

两个接口作用相似，都可以通过对象工厂创建对象。