第三阶段---day02

1.spring

1.1 spring介绍

spring框架是一个开放源代码的J2EE应用程序框架,是针对bean声明周期进行管理的轻量级容器

知识点:
1.J2SE 基础的java语法
2. J2EE Java企业级开发
3. J2ME 移动端Java开发 手机qq Java写的
4. bean :由spring容器管理的对象称之为bean
5. 轻量级:使用spring容器的方式简单/操作便捷
6. 容器:spring在内存中开辟一大块空间,用来管理对象
总结: spring是开源的J2EE应用框架,是管理Bean生命周期的轻量级容器

1.2 传统项目开发

1.2.1 创建Dog类

package com.jt.demo1;

public class Dog{
 public void hello(){
 System.out.println("小狗,不咬人");
 }
}

1.2.2 创建Cat类

package com.jt.demo1;

public class Cat{
	public void hello(){
		System.out.println("小猫,掉毛");
	}
}

1.2.3 编辑测试类

package com.jt.demo1;

public class User{
/*
*分析这段代码有何特点:
*1.如果用户需要切换属性,则手动的修改代码
*2.每个宠物对象都当前的user'类紧紧地绑定在一起,后期维护不易
*总结:这样的程序耦合性极高
*/

//用户需要调用hello方法    因为需要调用cat的方法hello所需要有一个cat对象 
private static Cat cat = new Cat();

public static void main (String[] args){
	System.out.println("用户调用方法");
	Cat.hello();
}

}

1.2.4 测试问题总结

1.如果类中额属性通过new的方式直接绑定,则类与属性耦合性高
2.如果需要修改属性类型,则需要修改代码,后期扩展不方便

1.3面向接口开发----重点内容

1.3.1 定义接口

package com.jt.demo2;
public interface Pet{
	//接口的作用:抽取一些公共方法
	public void hello();   //public默认存在 会省略
}

1.3.2 定义宠物实现类

1.定义狗

package com.jt.demo2;
public class Dog implements Pet{
	@override
	public void hello(){
		System.out.println("小狗汪汪汪");
	}
}

2.定义猫

package com.jt.demo2;

public class Cat implements Pet{
	@override
	public void hello(){
		System.out.println("小猫 喵喵喵");
	}
}

1.3.3 定义用户类

package com.jt.demo2;
public class User{
	//用户可以使用接口当做属性
	//面向接口开发,以后的方法的属性名称不用更改
	private  static Pet pet = new Cat();  //使用了多态

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

}

1.4 Spring-IOC介绍 重点知识

1.4.1 现在的问题

说明:当前的cat dog对象与user类仅仅的绑定在一起 耦合性高

1.4.2 IOC介绍

IOC 全称:inversion of control,即"控制反转",这是一种设计思想,对象创建的权利由spring框架完成,由容器管理对象的生命周期

1.4.3 IOC入门案例

1.4.3.1 准备dog类

1.4.3.2 准备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">

    <!--1. IOC的机制管理Dog对象
        id: 对象的唯一标识符. 不能重复 见名知意 首字母小写
        class: 类路径
    -->
    <bean id="dog" class="com.jt.demo3.Dog"></bean>

</beans>

1.4.3.3 编辑User测试对象

package com.jt.demo3;

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

public class User{
//IOC
	public static void main(String[] args){
	//1.指定配置文件
	String resource = "spring.xml";
	//2.创建容器对象 加载配置文件   其实就是根据配置文件加载bean对象
	ApplicationContext context = 
				new ClassPathXmlApplicationContext(resource);
	//3.从容器中获取对象
	Dog dog =context.getBean(Dog.class);
	//4.调用对象的方法
	dog.hello();
	
}

}

1.4.4 IOC对象创建–反射机制

package com.jt.demo3;

public class NewDog{
	/**
	*1.该方法是通过反核机制实例化对象,框架中的重点
	*2.反射机制:
	*Java中通过创建对象的常用的一种方法,指定类型的路径,
	*之后通过关键方法 .newInstance()实例化对象
	*类比 :    xxx.newInstance() ~~~ new Dog();
	*3.精髓: 为什么用反射而不是new?
	*		3.1:因为第三方通过反射实例化对象,可以实现松耦合
	*		3.2一般多用于框架,因为框架不清楚用户到底需要什么,只有运行期
	*			才会清楚用户到底需要什么对象,扩展性更好
	*4. 异常说明
	* 	1.运行时异常:运行期间出错了
	* 	2.编译异常/检查异常: 编译时提示报错
	*
	*/


//使用类加载器实例化对象
public static void main(String[] args)  throws ClassNotFoundException, InstantiationException, IllegalAccessException{
	Dog dog =(Dog) Class.forName("com.jt.demo3.Dog").newInstance();
	dog.hello();
}

}

1.4.5 IOC实现原理

容器的数据结构:K-V Map<K,V> key=bean中的id ,value=实例化的对象
程序执行过程:
1.指定配置文件
2.当spring容器加载配置文件时,当按照顺序执行bean标签时,开始创建对象
3.spring通过bean标签中的class属性获取类型的路径,之后通过反射机制,实例化对象(必须有无参构造)
4.bean中的id当做map中的key,将实例化的对象保存在map中,当做value 至此spring容器启动成功
5.当用户需要获取对象时,可以通过key或者类型获取对象

1.5 spring注解开发

1.5.1 关于注解开发说明

在引入springboot之后,基本不需要使用xml配置文件了,一般使用注解开发

1.5.2 编辑配置类

效果:和配置文件类似
注解作用:标识/标记
注解1:@Configuration
注解2:@Bean
注解3:@ComponentScan(“com.jt.demo4”) //包扫描注解,让spring注解生效

package com.jt.demo4;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration//标识当前类是配置类
@ComponentScan("com.jt.demo4") //包扫描注解,让spring注解生效
public class SpringConfig{
//作用:和配置文件类似,管理对象
/*
*IOC-写法
*1.@Bean 告诉spring容器,当前方法的名称为map中的key 返回值是map中的value
*2.特殊用法:
*	常规条件下:spring通过反射实例化对象
*	也可以由用户自己new'的方式创建对象
**/
@Bean
public Dog dog(){
	return new Dog();

}

}

1.5.3 编辑测试类

package com.jt.demo4;


public class User{
	public static void main(String[] args){
		ApplicationContext context = 
						new AnnotationConfigApplicationContext(SpringConfig.class);
		Dog dog = context.getBean(Dog.class);
		dog.hello();

}

}

1.6 第三阶段所有注解

https://harrylyj.blog.csdn.net/article/details/122357374

1.7 spring中单例和多例问题

1.7.1 概念说明:

单例对象: spring中只保存一份
多例对象:spring容器负责创建多次对象,内存中对象多份

1.7.2 单例 多例测试

注解:@Scope 默认是单例
… …单例: @Scope(“singleton”)
… …多例:@Scope(“prototype”)
结论:
1.spring容器默认条件下,对象都是单例对象,节省内存空间
2.spring容器提供了多例对象的方法,一般适用 数据库连接/资源链接等功能

1.8 spring中的懒加载

知识回顾:
懒汉式:用户使用时创建
饿汉式:不管需不需要都创建

懒加载:默认条件下spring容器启动时都会实例化对象,如果用户使用时创建对象,则使用懒加载机制
规则:
1.spring容器启动,对象创建,不是懒加载
2.当用户使用时创建对象,是懒加载

注意事项:
1.如果当前对象是多例模式,则都是懒加载
2.懒加载的控制 只对单例对象有效