文章目录
Spring学前基础
依赖
1.依赖构成的3个要素
1.1组id
1.2项目名
1.3版本号
2.坐标和本地仓库的关系
根据坐标去本地仓库。查找jar文件
这边都是路径，指向需要的文件
3.如果依赖项报错，首先检查本地仓库的jar包是否正确
maven中jar包依赖的传递性
A依赖B，B依赖C，导入A时BC都会导入
如何实现？
1.根据坐标查找本地仓库的jar包文件
2.查找jar包文件之后，查找**.pom文件**，之后查找里面的依赖项
3.之后根据新坐标查找jar包，查找**.pom文件**，循环操作
pom文件中找dependency中的坐标，然后找jar文件
SHA1算法
SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数。
Hash相关知识
问题1：对相同数据采用相同hash算法，结果是否相同？
答案：相同
hash本质是函数，变量相同，结果相同。如f（x）=x^2
问题2：对不同数据采用相同hash算法，结果是否相同？
答案：可能相同
Hash碰撞
不同的数据结果相同的hash算法，得到了相同的结果，称为hash碰撞。
hash碰撞在数学界没办法规避
数据传输安全保证
如果在jar包传输过程中对jar包做了手脚，如加入木马病毒。
对比前后消息摘要即可，不同则丢弃，重新下载
build标签
-
build中的插件缺一不可
-
mainClass中的路径必须与主启动类一致
-
如果复制代码，copy dependencies内容即可
maven常用命令
1. clean指令
删除项目中target目录，即删除编译后的文件
2.compile指令
用maven工具编译.java文件–>.class
3.install指令
将开发完的项目打包部署，将项目形成xxx.jar包文件
作用：
1.如果开发的是工具API/框架打成jar包，之后其他用户通过依赖的关系可以使用该jar包
2. 可以将项目打成jar包直接部署,用户可以通过网址直接访问
存储位置:
-
target目录下 会有jar包文件
-
根据maven坐标,会在本地仓库中生成jar包.
项目发布命令
说明: 未来项目的发布环境都是Linux系统(纯dos命令)
命令: java -jar xxxxx.jar 回车
这边执行的就是上面install生成的jar包，重命名了一下
Spring-IOC
Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器。
-
J2SE java基础 J2EE java企业级开发 J2ME 移动端开发
-
bean: spring容器管理的对象称之为bean
-
生命周期: 对象创建/对象的初始化/对象执行业务逻辑/对象销毁
-
轻量级容器: Spring在内存中申请了一块内存空间,用来存储其它对象.
面向接口编程
向上抽取，简化开发,这时接口用来定义行为规范准则
面向接口编程优势：解决了属性与方法名之间的耦合，以后几乎可以不修改属性名
面向接口编程的弊端：接口对象还是一一指向子类对象，后期维护还是要修改源码
Spring-IOC介绍
原理
IOC-Inversion of Control,控制反转，一种思想，对象的创建权利由Spring框架完成，由容器管理对象的生命周期，需要的时候进行依赖注入（DI）即可。
XML开发
将Dog对象交给Spring容器管理。交给容器管理的对象也叫bean
说明: spring早期都使用配置文件的方式来管理对象.但是随着软件的升级当下注解的方式已经成为主流. 所以先完成xml配置文件的方式,之后完成注解的方式.
内容说明: xml文件 一般都会有固定的头标签
package demo2;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringGetDog {
//从spring容器获取Dog对象
//Dog对象创建好了，配置文件也进行了匹配
public static void main(String[] args) {
System.out.println("**********");
//1.读取Spring配置文件路径
String resource="spring.xml";
//2.启动Spring容器
ApplicationContext context =
new ClassPathXmlApplicationContext(resource);
//3.从容器中获取对象
//这边会应用反射机制创建对象
// Dog dog = (Dog) context.getBean("dog");
System.out.println("***************");
Dog dog2 = context.getBean(Dog.class);
System.out.println(dog2);
dog2.hello();
//反射机制获取对象
getDog();
}
//实例化对象的核心原理，反射机制
public static void getDog(){
try {
//反射创建对象
//反射会调用对象的无参构造
Dog dog = (Dog) Class.forName("demo2.Dog").newInstance();
dog.hello();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
package demo2;
public class Dog {
public void hello(){
System.out.println("小狗，spring容器管理");
}
public Dog() {
System.out.println("wucan");
}
}
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">
<!-- id是bean的唯一标识符，一般类名首字母小写-->
<bean id="dog" class="demo2.Dog"></bean>
<!-- <bean id="cat" class="demo2.Cat"></bean>-->
</beans>
输出结果：
Spring创建对象的步骤！！！重要！！！
- 指定Spring配置文件的地址。
- Spring容器启动时加载指定的配置文件。
- 当Spring扫描到bean标签时，加载属性id和class
- 根据反射机制 根据class的路径反射实例化对象
- Spring在内部维护了一个大型的Map<k,v>集合（容器）,bean中的id当key，实例化的对象当value。形式：Map<id,实例化对象>
- 从Spring容器中通过id或者class类型获取对象
- 根据对象调用业务方法
注解开发
组成部分：
1.实体类：Spring容器管理的类（对象）
2.配置类：相当于早期的xml配置文件
3.测试代码：利用注解的方式启动Spring容器
package demo3;
public class Cat {
public Cat(){
System.out.println("cat的无参构造");
}
public void hello(){
System.out.println("cat miaomiaomiao~");
}
}
package demo3;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@ComponentScan("demo3")//根据指定的包路径扫描注解,扫描当前包和其子包
@Configuration//标识当前类是配置类 其实就是配置文件
public class SpringCatConfigure {
/*
* 方法要求：
* 1.必须为共有的 public
* 2.必须添加返回值，返回值的对象就是容器管理的对象
* 3.方法的名称就是bean的id
* 4.方法必须使用@Bean注解标识,Spring才会执行该方法，标识该对象交给Spring容器
* */
@Bean
public Cat cat(){
return new Cat();
}
}
package demo3;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class SpringAnno {
public static void main(String[] args) {
ApplicationContext context=
new AnnotationConfigApplicationContext(SpringCatConfigure.class);
Cat cat = context.getBean(Cat.class);
cat.hello();
}
}
Spring中的单例，多例模式
Spring中的对象默认是单例的
@Scope
单例模式的时候，注意创建对象的位置 是最长的那行代码
原因好像是因为饿加载
多例模式的时候，只要加一个Scope注解，然后还是执行上面的代码，
创建对象时执行的代码与单例模式有所不同，因为是懒加载模式
Spring中的懒加载
默认条件下，Spring启动则会创建对象（类比饿汉式）
如果开启了懒加载，则用户什么时候启动，对象就什么时候创建（类比懒汉式）
懒加载之后就是在下面这行代码创建对象
因为多例模式默认是懒加载，所以懒加载只能控制单例模式
Spring的生命周期
阶段划分：对象创建、初始化、
注解总结
@ComponentScan("demo3") //根据指定的包路径扫描注解
@Configuration //标识当前类是配置类
@Bean //标识该方法返回值交给Spring容器管理
@Scope("prototype") //控制单例多例模式
@Lazy //懒加载
@PostConstruct //初始化方法，构造方法后执行
@PreDestroy ///销毁方法，close之后执行
Spring执行步骤！！！！
自己按照事例小结的
1.先写自己需要用的类，如cat dog等等
2.写配置文件，配置注解@Configureation@ComponentScan
配置文件中，加入@Bean把上面写的类交给Spring容器管理
3.写测试类，用Spring容器执行想要执行的内容，先启动Spring容器，加载配置类（2），再用容器获取想要的对象，即获取（1）
Spring依赖注入（DI）
依赖注入案例
Dog类 子类，实现Pet接口
package demo4;
import org.springframework.stereotype.Component;
@Component//将该类交给Spring容器管理 key：dog value：反射机制创建对象
public class Dog implements Pet{
@Override
public void hello() {
System.out.println("小皮狗，汪汪汪!!!");
}
public Dog(){
System.out.println("dog的无参构造");
}
}
Pet接口
package demo4;
public interface Pet {
void hello();
}
User类，里面注入Pet接口
package demo4;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;
@Component //将User对象交给Spring容器管理
public class User {
/**
* 注入：将Spring容器中的对象进行引用！！！
* @Autowired: 可以将容器中的对象进行注入
* 1.按照类型注入
* 如果注入类型是接口，则自动查找其实现类对象进行注入，本例就可以直接找到 Dog类
* 注意：一般Spring框架内部接口都是单实现。（特殊条件下可以多实现）
* 2.按照名称注入
*/
@Autowired //Pet接口没有交给Spring，如果不注入，则Spring无法调用此pet对象
private Pet pet;
public void hello(){
pet.hello();
}
}
配置类
package demo4;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@ComponentScan("demo4")
@Configuration
public class SpringConfigure {
}
实现类
package demo4;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class SpringDI {
public static void main(String[] args) {
ApplicationContext context=
new AnnotationConfigApplicationContext(SpringConfigure.class);
System.out.println("============================================");
User user = context.getBean(User.class);
user.hello();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7OiE4vkg-1642510086205)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220118195508044.png)]
注意
1.类交给Spring容器管理之后，就会放在Map里面，key：是类的id
value是用反射机制创建的对象，这个过程会执行类的无参构造
-
注入：将Spring容器中的对象进行引用！！！
@Autowired: 可以将容器中的对象进行注入
1.按照类型注入
如果注入类型是接口，则自动查找其实现类对象进行注入，本例就可以直接找到 Dog类
注意：一般Spring框架内部接口都是单实现。（特殊条件下可以多实现）
2.按照名称注入
-
注意看上面代码的注释，理解代码执行过程。
("============================================");
User user = context.getBean(User.class);
user.hello();
}
}
[外链图片转存中...(img-7OiE4vkg-1642510086205)]
## 注意
1.类交给Spring容器管理之后，就会放在Map里面，key：是类的id
value是用反射机制创建的对象，这个过程会执行类的无参构造
2. 注入：将Spring容器中的对象进行引用！！！
@Autowired: 可以将容器中的对象进行注入
1.按照类型注入
如果注入类型是接口，则自动查找其实现类对象进行注入，本例就可以直接找到 Dog类
注意：一般Spring框架内部接口都是单实现。（特殊条件下可以多实现）
2.按照名称注入
3. 注意看上面代码的注释，理解代码执行过程。
4. **注入的优点**：不用再去new对象，注解会直接帮助找到实现类的对象
