【学习笔记】Spring-IOC-DI-AOP 学习笔记

1.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标签

1. build中的插件缺一不可

2. mainClass中的路径必须与主启动类一致

3. 如果复制代码，copy dependencies内容即可

maven常用命令

1. clean指令

删除项目中target目录，即删除编译后的文件

2.compile指令

用maven工具编译.java文件–>.class

3.install指令

将开发完的项目打包部署，将项目形成xxx.jar包文件

作用：

​ 1.如果开发的是工具API/框架打成jar包，之后其他用户通过依赖的关系可以使用该jar包

​ 2. 可以将项目打成jar包直接部署,用户可以通过网址直接访问

存储位置:

1. target目录下 会有jar包文件

   

2. 根据maven坐标,会在本地仓库中生成jar包.

项目发布命令

说明: 未来项目的发布环境都是Linux系统(纯dos命令)
命令: java -jar xxxxx.jar 回车

这边执行的就是上面install生成的jar包，重命名了一下

2.Spring-IOC

Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器。

1. J2SE java基础 J2EE java企业级开发 J2ME 移动端开发

2. bean: spring容器管理的对象称之为bean

3. 生命周期: 对象创建/对象的初始化/对象执行业务逻辑/对象销毁

4. 轻量级容器: Spring在内存中申请了一块内存空间,用来存储其它对象.

面向接口编程

向上抽取，简化开发,这时接口用来定义行为规范准则

面向接口编程优势：解决了属性与方法名之间的耦合，以后几乎可以不修改属性名

面向接口编程的弊端：接口对象还是一一指向子类对象，后期维护还是要修改源码

Spring-IOC介绍

原理

IOC-Inversion of Control,控制反转，一种思想，对象的创建权利由Spring框架完成，由容器管理对象的生命周期，需要的时候进行依赖注入（DI）即可。

1.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>

输出结果：

2.Spring创建对象的步骤！！！重要！！！

1. 指定Spring配置文件的地址。
2. Spring容器启动时加载指定的配置文件。
3. 当Spring扫描到bean标签时，加载属性id和class
4. 根据反射机制 根据class的路径反射实例化对象
5. Spring在内部维护了一个大型的Map<k,v>集合（容器）,bean中的id当key，实例化的对象当value。形式：Map<id,实例化对象>
6. 从Spring容器中通过id或者class类型获取对象
7. 根据对象调用业务方法

3.注解开发

组成部分：

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中多例模式@Scope

Spring中的对象默认是单例的

@Scope

单例模式的时候，注意创建对象的位置 是最长的那行代码

原因好像是因为饿加载

多例模式的时候，只要加一个Scope注解，然后还是执行上面的代码，

创建对象时执行的代码与单例模式有所不同，因为是懒加载模式

Spring中的懒加载

默认条件下，Spring启动则会创建对象（类比饿汉式）

如果开启了懒加载，则用户什么时候启动，对象就什么时候创建（类比懒汉式）