1.1Spring介绍

Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器(lightweight container)。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IQC、AQP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、 Tapestry等众多Web框架组合使用，并且可以与Swing等桌面应用程序AP组合。因此，Spring不仅仅能应用于JEE应用程序之中，也可以应用于桌面应用程序以及小应用程序之中。Spring框架主要由七部分组成，分别是Spring Core、Spring AOP、Spring ORM、Spring DAQ、Spring Context、Spring Web和Spring Web MVC。

小结：Spring由Rod Johnson研发，Spring框架是针对bean的生命周期进项管理的轻量级容器。其中核心技术IOC 和AOP

1.2传统开发存在的问题

1.2.1编辑Dog类

package com.jt;

public class Dog  {
    public void hello(){
        System.out.println("你好，小狗");
    }
}

1.2.2编辑Cat类

package com.jt;

public class Cat {
    public void hello(){
        System.out.println("你好，小猫");
    }
}

1.2.3编测试类

package com.jt;

public class User {
    private static Cat cat=new Cat();

    public static void main(String[] args) {
        cat.hello();
    }
}

1.2.3问题描述

问题描述：

1. 宠物对象与当前的用户紧紧的绑定在一起. 耦合性高 * 2. 对象与方法紧紧的绑定在一起. 耦合性高

1.3面向接口开发

1.3.1业务说明

1.Dog类中和Cat类中都有hello方法，可以将hello的方法进行抽取，代码逐步演化为面向接口的方式。

1.3.2定义Pet接口

package com.jt;

public interface Pet {
    void hello();
}

1.3.3编辑现实类对象

1.编辑Cat类

package com.jt;

public class Cat implements Pet{
    public void hello(){
        System.out.println("你好，小猫");
    }
}

2.编辑Dog类

package com.jt;

public class Dog implements Pet {
    public void hello(){
        System.out.println("你好，小狗");
    }
}

1.3.4编辑测试类

public class User {

/**
 *  说明： 如果用户喜欢狗
 *  讨论： 这样的代码有什么问题
 *  问题描述:
 *      1. 宠物对象与当前的用户紧紧的绑定在一起. 耦合性高
 *      2. 对象与方法 紧紧的绑定在一起. 耦合性高
 */
//private static Dog dog = new Dog();
//private static Cat cat = new Cat();
//面向接口开发: 优势解决了属性与方法的耦合性问题
private static Pet pet = new Cat();

public static void main(String[] args) {
    pet.hello();
}
}

1.3.5关于面向接口编程的说明

面向接口编程可以解决属性与方法之间的耦合性问题.
问题描述: 当前new Cat对象与当前的类紧紧的绑定在一起. 如果后期需要修改Cat 则每个类中都需要修改. 耦合性高.

1.4Spring-IOC(inversion of Control)

1.4.1IOC介绍

Ioc全称Inversion of Control，即“控制反转”，这是一种设计思想。对象创建的权利由Spring框架完成.由容器管理对象的生命周期.

小结:\

原来的对象的创建都是由用户自己手动创建,这样的方式耦合性肯定高. 如果类发生了变化,则代码都得修改.\
现在所有的对象都交给Spring容器管理. 用户无需关心对象是如何实例化. 容器负责对象的注入即可. 以后几乎不用修改任何代码. 降低了代码的耦合性

1.4.2IOC项目创建

1.4.3创建User类

package com.jt.demo;

public class User {
    public void say(){
        System.out.println("我是user对象，被spring容器管理");
    }
}

1.4.4编辑spring.xml配置文件

说明: 由于需要使用Spring的框架,所以需要准备spring的配置文件. 在resource中创建spring.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">

    <!--
        该配置文件作用是管理对象
        术语: bean  被spring容器管理的对象称之为bean
        属性说明:
                id: 是spring容器中对象的唯一标识符.不能重复
                class: 对象的全路径
    -->
    <bean id="user" class="com.jt.demo.User"></bean>
    <!--<bean id="user" class="com.jt.demo.User"/>-->

</beans>

1.4.5编辑测试API

package com.jt;

import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {

    //spring管理对象的测试API
    @Test
    public void testDemo1(){
        String resource  = "spring.xml";
        //创建spring容器. 并且加载指定的配置文件 对象已经交给容器管理
        ApplicationContext context =
                    new ClassPathXmlApplicationContext(resource);
        //从容器中获取对象
        User user1 = (User) context.getBean("user");
        User user2 = context.getBean(User.class);
        user2.say();
    }
}

1.5关于Spring容器

解释：

Spring容器的数据结构是Map集合. Map<key,value>
key=“user” value=“通过反射机制实例化的对象”

1.6了解反射源码

说明: 反射机制在框架中一般使用比较多,给定类型的路径就可以获取其中的对象.但是要求必须有无参构造. 否则程序运行必报异常.

 @Test
    public void testDemo2() throws ClassNotFoundException, IllegalAccessException, InstantiationException {

        User user =
                (User) Class.forName("com.jt.demo.User").newInstance();
        user.say();
    }

2.Spring注解开发

2.1关于Spring注解开发的说明

大约在2015年以前框架的开发需要大量的xml配置文件。导致项目配置比较臃肿,开发效率略低. 但是项目整合时的报错概率很高. Spring与时俱进从3开始逐步演化为注解开发. 到了SpringBoot框架的诞生,标志着进入了全注解时代.

2.2创建springdemo3_anno项目

2.3注解开发的步骤

2.3.1编辑User类

package com.jt.demo;

public class User {

    public void say(){
        System.out.println("使用全注解的方式管理对象");
    }
}

2.3.2编辑配置类

说明: 原始的开发使用xxx.xml文件用来管理对象, 现在都使用java类的形式当作配置文件则将该java类 称之为配置类.

package com.jt.config;

import com.jt.demo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration //将当前类标识为配置类
public class SpringConfig {//xml
    /**
     *  1.xml形式
     *      <bean id="user" class="com.jt.demo.User"></bean>
     *  2.注解形式
     *     Map集合的结构 Map<方法名,方法的返回值>
     *     @Bean 将方法的返回值,交给Spring容器管理.
     */
    @Bean
    public User user(){

        return new User(); //相当于xml反射机制创建对象
    }
}

2.3.3编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {

    //利用注解的方式管理对象
    @Test
    public void testDemo1(){
        //1.利用注解的方式启动spring容器
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        //2. 从容器中获取对象
        User user = context.getBean(User.class);
        //3. 对象调用方法
        user.say();
    }
}

2.4关于IOC总结

什么是IOC 由Spring容器管理对象的生命周期,降低代码耦合性
xml配置文件管理对象
1.准备xxx.xml配置文件 2.准备bean标签
3.spring容器管理对象
ApplicationContext容器顶级接口
ClassPathXmlApplicationContext 加载配置文件的实现类对象
全注解的方式管理对象
准备配置类 @Configuration + @Bean

要求方法必须有返回值

容器对象
ApplicationContext容器顶级接口
AnnotationConfigApplicationContext

万能语法: 根据当前spring的配置规则,实例化接口对象. 我一般不写这些代码,如果想看也可以通过ApplicationContext 查找指定的实现类.

2.5spring创建对象——工厂模式（必会内容）

2.5.1关于对象管理问题说明

问题: 任意对象都可以通过new的关键字实例化吗?
答案: 当然不是, 抽象类对象不可以直接实例化.

2.5.2创建项目springdemo4_factory

2.5.3关于spring中注解说明

@Component 将当前的类,交给Spring容器管理, 对象的创建是由Spring通过反射机制自动创建对象.
@ComponentScan(“com.jt”) 指定扫描的包路径, 可以扫描它的子孙包,用在配置类中

2.5.4代码结构

2.5.5编辑配置类

package com.jt.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
//准备一个配置类
@Configuration
@ComponentScan("com.jt")
//当spring容器启动时,根据指定的包路径,扫描其子孙包
public class SpringConfig {


}

2.5.6编辑User类

package com.jt.demo;

import org.springframework.stereotype.Component;
//Spring容器管理  Map<类名首字母小写:user,实例化的对象>
@Component
public class User { //spring容器通过反射机制实例化对象

    public void say(){
        System.out.println("通过@Component注解实例化对象");
    }
}

2.5.7编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestSpring {

    @Test
    public void testDemo1(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = context.getBean(User.class);
        user.say();
    }
}

2.5.8利用工厂模式创建对象（了解就行）

2.5.8.1业务说明

Spring中管理的对象,大部分可以通过new/反射进行对象的创建. 但是有些对象由于特殊的原因.不能直接new/实例化.这时需要考虑是否可以通过工厂模式实现.
例如: Calendar 该类是一个抽象类所以不能直接实例化

2.5.8.2创建工厂模式

package com.jt.factory;

import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;

import java.util.Calendar;

/**
 * FactoryBean是Spring提供的接口,spring自动完成调用.获取指定的对象
 * 难点讲解:
 *      1.@Component 标识类 则将该类交给Spring容器管理.
 *      2.Spring中FactoryBean的讲解
 *          如果spring加载的时候遇到FactoryBean接口
 *          则会自动的执行重写的方法getObject/getObjectType
 *      3.工厂模式说明:
 *          Map<Key:calendar,value=Calendar对象></>
 *
 *      核心功能:
 *              1. key: 就是当前类型(如果自己编辑注解以注解为准)
 *              2. value: 调用getObject获取的返回值对象
 *              将上述的数据,交给Spring容器管理
 *      该功能什么时候使用:
 *              1. 某些对象不能直接实例化的.
 *              2. 整合其它第三方框架对象时 经常使用.
 */
@Component("calendar")
public class CalendarFactory implements FactoryBean<Calendar> {

    public CalendarFactory(){
        System.out.println("工厂模式的无参构造");
    }

    //现阶段 大家理解为主. 未来写结构设计的时候,作用很大!!!!!
    //动态执行该方法,获取返回值对象
    @Override
    public Calendar getObject() throws Exception {
        //利用calendar的工具API 实现对象的创建
        return Calendar.getInstance();
    }

    @Override
    public Class<?> getObjectType() {
        //固定写法. 一般直接xxx.class即可
        return Calendar.class;
    }
}

2.5.8.3编辑测试

  @Test
    public void testDemo2(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        //Calendar calendar = context.getBean(Calendar.class);
        Calendar calendar = (Calendar) context.getBean("calendar");
        System.out.println("获取当前时间:"+calendar.getTime());
        System.out.println("获取年:"+calendar.getWeekYear());
    }

2.6注解复习

1.@Configuration 标识配置类

2.@Bean 将自己方法的返回值交给Spring容器管理

3.@Component 将该类交给spring容器管理，通过反射自动实例化对象

4.@ComponentScan("com.jt")包扫描的注解使Spring注解有效

spring入门