Hellospring 笔记

最新推荐文章于 2020-06-06 07:23:40 发布

Kiko_Fan

最新推荐文章于 2020-06-06 07:23:40 发布

阅读量175

点赞数

本文链接：https://blog.csdn.net/Kiko_Fan/article/details/103648155

版权

Helloword.java

package com.spring.test;

public class Helloword {	
	private void init() {
	System.out.println("初始化");
	}
	public void print() {
		System.out.println("hello word");
	}
	private void destroy() {
	System.out.println("结束");

	}
}

applicationContext.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"  
xmlns:aop="http://www.springframework.org/schema/aop"   
xmlns:context="http://www.springframework.org/schema/context"  
xmlns:jee="http://www.springframework.org/schema/jee"  
xmlns:lang="http://www.springframework.org/schema/lang"  
xmlns:util="http://www.springframework.org/schema/util"  
xmlns:tx="http://www.springframework.org/schema/tx"  
xmlns:mvc="http://www.springframework.org/schema/mvc"    
xsi:schemaLocation="http://www.springframework.org/schema/beans  

 http://www.springframework.org/schema/beans/spring-beans.xsd   
 http://www.springframework.org/schema/aop    
 http://www.springframework.org/schema/aop/spring-aop.xsd   
 http://www.springframework.org/schema/jee    
 http://www.springframework.org/schema/jee/spring-jee.xsd   
 http://www.springframework.org/schema/lang    
 http://www.springframework.org/schema/lang/spring-lang.xsd   
 http://www.springframework.org/schema/context    
 http://www.springframework.org/schema/context/spring-context.xsd   
 http://www.springframework.org/schema/tx    
 http://www.springframework.org/schema/tx/spring-tx.xsd   
 http://www.springframework.org/schema/util    
 http://www.springframework.org/schema/util/spring-util.xsd   
 http://www.springframework.org/schema/mvc    
 http://www.springframework.org/schema/mvc/spring-mvc.xsd">
 <bean id="test" class="com.spring.test.Helloword"></bean> 

<!--默认单例 -->
<!-- <bean id="test" class="com.spring.test.Helloword" scope=""></bean> -->

<!--声明为单例模式  -->
<!-- <bean id="test" class="com.spring.test.Helloword" scope="singleton"></bean>-->

<!--声明为多例模式  -->
<!-- <bean id="test" class="com.spring.test.Helloword" scope="prototype"></bean> -->

<!-- 初始方法和销毁方法 -->
<!-- <bean id="test" class="com.spring.test.Helloword" scope="prototype" init-method="init" destroy-method="destroy"></bean> -->

<!-- 初始方法和销毁方法，把多例改为单例，销毁 方法可执行-->
<!-- <bean id="test" class="com.spring.test.Helloword" scope="singleton" init-method="init" destroy-method="destroy"></bean> -->
<!-- sett注入 -->
<!-- 
<bean id="helloword" class="com.spring.test.Helloword"></bean>
<bean id="sett" class="com.spring.test.Person">
<property name="age"  value="17"></property>
<property name="username" value="zhangsan"></property>
<property name="test" ref="helloword"></property>
</bean>
 -->
	</beans>

person.java

package com.spring.test;

public class Person {
	private Helloword test;
	private int age;
	private String username;
	public Helloword getTest() {
		return test;
	}
	public void setTest(Helloword test) {
		this.test = test;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	@Override
	public String toString() {
		return "Person [test=" + test + ", age=" + age + ", username=" + username + "]";
	}
	
	public void test() {
		test.print();
	}
	
}

Test.java

package com.spring.test.HelloWord;

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

import com.spring.test.Helloword;
import com.spring.test.Person;

public class Test {
	public static void main(String[] args) {
//		Helloword test = new Helloword();
//		test.print();
//上面两句相当于下面的3句
//		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//	    Helloword bean = (Helloword) context.getBean("test");
//		bean.print();

//检验默认单例模式（测试结果返回true）/声明单例模式（测试结果返回true）/多例模式（测试结果返回false）		
//		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//	    Helloword bean = (Helloword) context.getBean("test");
//		Helloword bean1 = (Helloword) context.getBean("test");
//		System.out.println(bean == bean1);
		
//初始方法和销毁方法测试（测试结果destroy不执行）
//		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//	    Helloword bean = (Helloword) context.getBean("test");
//		bean.print();

//初始方法和销毁方法测试-子类和父类类型改为一样，出现close方法（测试结果destroy仍然不执行）,需要把xml中的多例改为单例，destroy即可执行
//		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//	    Helloword bean = (Helloword) context.getBean("test");
//	    context.close();
//		bean.print();
		
//sett注入测试
//		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//		Person bean = context.getBean("sett",Person.class);
//		bean.test();
//		System.out.println(bean);//调用tostring方法
	    
	   
	}

}

Spring（ 3天） XML配置太多
Mybatis（ 2天）
了解SSH框架和SSM框架有什么区别底层封装不一样
SpringMVC 底层封装是sevlet （3-4天）
Springboot 不用配置XML，几个注解可以搞定

Spring
Spring的优点：Di ioc（容器的概念） aop 事务
源代码所占内存空间比较小
控制反转、面向切面、容器
Spring框架特点：
① 高内聚，低耦合（解决耦合问题）
一个类有关的属性和方法会放在这个类中
高内聚是这个类所做的事情，所有与这个类相关的关系
低耦合讲的是类与类之间的依赖
例子：

class A
Public void print（）

class B extend A
Main
B b=new B
b.print（）

② AOP面向切面编程（ jdk动态代理）

class A
Public void print(){
System.out.println(“hello world”)
}
Public void printTwo(){
System.out.println(“hello world”)
}

把通知放到切面里面去，实现把开始放到hello world之前

class B extend A
Main
B b=new B
b.print()

③ 事务
事务的概念：①原子性(A)②一致性©③隔离性(I)④持久性(D)
+name+ 可用+?+ sql注入，用占位符的方式
日志详细记录了这个人做件事之前和之后做的事情

JAVA体系结构
应用层
业务层 spring
持久层

Spring在业务层
每一层都有对象，都要交给spring管理
Asp自定义编程
JDBC访问数据库有弊端，每次都要访问对象连接，频繁开关，数据库资源的浪费
JDBC存在硬编码设置成XML
数据库用mybatis
Context要对类路径进行扫描
使用说明文件（约束文件）-docs
XML写在src下面，要引入约束文件-把类交给spring管理的时候，xml就是工厂，这个工厂需要接受原材料的工厂（相当于类），xml是识别一个类的工具，给明类路径，即是产生包子的路径

<bean class=”com.spring.test.Helloword”></bean>
/*Helloword test=new helloword();*/

专业词汇
Ioc：控制反转
类交给spring容器管理，spring不是立马把对象给我，而是通过另外的处理，接收是被动的。拿对象就是反转。（给钱后，不是直接把包子给你，而是通过其他营业员被动的接收）
IoC 容器控制了对象，主要控制了外部资源获取（不只是对象包括比如文件等）反转：由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，哪些方面反转了？依赖对象的获取被反转了。

Helloword bean = (Helloword) context.getBean("test");

Di：
Aop：
⭐生命周期作用域（面试一定会问到）
生命周期和作用域都是针对变量而言
局部变量的作用域就在花括号内
作用域：Scope 有四个取值，分别是Prototype、request、session、Singleton 。
Prototype 多例
Singleton 单例：一种设计模式，这个类中只有一个对象，每new一个对象都有一个空间地址
在这里插入图片描述

验证单例模式：XML什么都不写，默认是单例。如果返回的是true，说明指向同一个地址，就是单例
①默认单例

<!--默认单例 -->
<!-- <bean id="test" class="com.spring.test.Helloword" scope=""></bean> -->

//检验默认单例模式（测试结果返回true）/声明单例模式（测试结果返回true）/多例模式（测试结果返回false）		
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
	    Helloword bean = (Helloword) context.getBean("test");
		Helloword bean1 = (Helloword) context.getBean("test");
		System.out.println(bean == bean1);

②XML声明是单例：

<!--声明为单例模式  -->
<!-- <bean id="test" class="com.spring.test.Helloword" scope="singleton"></bean>-->

验证多例模式：同样的测试代码，XML声明多例，返回的是false，说明指向多个地址

<!--声明为多例模式  -->
<!-- <bean id="test" class="com.spring.test.Helloword" scope="prototype"></bean> -->

结论

装配bean默认的就是singleton

生命周期：什么时候开始，什么时候结束（针对方法而言）
*⭐JAVA虚拟机怎么调优（面试一定会问到）

初始方法（init-method）和销毁方法（destroy-method）

必须是void

public class Helloword {	
	private void init() {
	System.out.println("初始化");
	}
	public void print() {
		System.out.println("hello word");
	}
	private void destroy() {
	System.out.println("结束");

	}
}

Test：测试结果是destroy没有执行

//初始方法和销毁方法测试（测试结果destroy不执行）
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
	    Helloword bean = (Helloword) context.getBean("test");
		bean.print();

把两边的类型改成一样，有close方法，但destroy仍任不执行，

//初始方法和销毁方法测试-子类和父类类型改为一样，出现close方法（测试结果destroy仍然不执行）,需要把xml中的多例改为单例，destroy即可执行
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
	    Helloword bean = (Helloword) context.getBean("test");
	    context.close();
		bean.print();

XML去掉了scope（即是单例），destroy可以执行
一个对象的时候可以销毁，多个对象的时候不知道销毁谁

<!-- 初始方法和销毁方法，把多例改为单例，销毁 方法可执行-->
 <bean id="test" class="com.spring.test.Helloword" scope="singleton" init-method="init" destroy-method="destroy"></bean>

总结：

Init-method：执行的是目标类中的初始化方法
Destroy-method：执行的是目标类中的结束方法
销毁的两个条件：
①	容器关闭 context.close();
如果两边类型不一样，编译不通过，因为父类没有close（）
 
②	此时装配的Bean一定要是单例（把XML中的scope删掉或者改成单例就行）**

di：依赖注入

class a{
Private b obj
}
Class b{
Private int age;
Private String username;
}

b继承了a，就要用a类对象，那怎么把值注入进去
依赖注入有三种：
默认构造（无参）、sett方法、有参构造、集合注入

① 默认构造
在装配bean的时候有默认无参构造

 <bean id="test" class="com.spring.test.Helloword" scope="" init-method="" destroy-method=""></bean>

② Sett方法注入
Javabean是一种开发规范

package com.spring.test;

public class Person {
	private Helloword test;
	private int age;
	private String username;
	public Helloword getTest() {
		return test;
	}
	public void setTest(Helloword test) {
		this.test = test;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	@Override
	public String toString() {
		return "person [test=" + test + ", age=" + age + ", username=" + username + "]";
	}
	
	public void test() {
		test.print();
	}			
}

回到XML重新配置bean
产生对象的时候，同时给属性赋初值

<!-- sett注入 -->
<bean id="helloword" class="com.spring.test.Helloword"></bean>
<bean id="sett" class="com.spring.test.Person">
<property name="age"  value="17"></property>
<property name="username" value="zhangsan"></property>
<property name="test" ref="helloword"></property>
</bean>

测试：
用接口new子类
不用进行强转，引入类路径

//sett注入测试
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		Person bean = context.getBean("sett",Person.class);
		bean.test();
		System.out.println(bean);//调用tostring方法

Sett注入的好处：
XML代码效率高于java代码
这个对象只是栈区，没有实际地址（缺少实际堆区的name），等待我们配置地址，运行测试必定是空值
Java代码：
栈区 Helloword test=new Helloword() 堆区两个对象
为什么是两个对象？Helloword类类型是一个对象，new也是一个对象
在这里插入图片描述

XML代码：

<!-- sett注入 -->
<bean id="helloword" class="com.spring.test.Helloword"></bean>
<bean id="sett" class="com.spring.test.Person">
<property name="age"  value="17"></property>
<property name="username" value="zhangsan"></property>
<property name="test" ref="helloword"></property>
</bean>

Test：

//sett注入测试
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		Person bean = context.getBean("sett",Person.class);
		bean.test();
	System.out.println(bean);//调用tostring方法

Sett方法注入有两种情况：
① 普通变量，值传递

<property name="age"  value="17"></property>
<property name="username" value="zhangsan"></property>

② 对象
在这里插入图片描述

 <property name="test" ref="helloword"></property>

Kiko_Fan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫