spring6框架解析(by尚硅谷)

文章目录

  • spring6
    • 1. 一些基本的概念、优势
    • 2. 入门案例实现
      • maven聚合工程创建步骤
      • 分析实现过程
    • 3. IoC(Inversion of Control)
      • 基于xml的bean环境搭建
      • 获取bean
      • 获取接口创建实现类
      • 依赖注入 setter注入 和 构造器注入
        • 原生方式的setter注入
        • 原生方式的构造器注入
        • 使用bean的方式进行依赖注入步骤
      • 对象类型属性赋值步骤
      • 引入外部属性文件步骤
        • bean的八大生命周期(重要)
      • 基于xml的bean自动装配
      • 基于注解的bean自动装配(极其重要)
        • 使用注解创建对象
      • 手动实现IoC
        • 实现过程
        • 手动实现一个IoC反射
        • 手动实现属性注入过程
    • 4. 面向切面编程
          • 静态代理图解
          • 静态代理术语
          • 动态代理
          • 动态代理的实现过程
      • 概念
      • 相关术语
      • AOP思想综述
      • 基于注解方式配置AOP
          • 通知类型及其使用
          • bean配置文件
          • 测试文件
          • 报错信息解决
          • 重用切入点表达式
    • 5. 单元测试
    • 6. 事务
      • JdbcTemplate对象操作Mysql数据库(Spring事务处理前置知识)
          • 准备环境
          • 利用JdbcTemplate对象完成对数据库的增加、修改、删除操作
          • 利用JdbcTemplate对象完成对数据库的查询操作
          • 报错信息解决
      • 事务处理
        • 概念
        • 特性
      • 声明式事务管理(基于注解实现)
        • 准备环境(基于上面的JDBC示例进行添加,目录结构如下)
            • BookController
            • BookDao
            • BookDaoImpl
            • BookService
            • BookServiceImpl
            • TestBookTx
          • 分析
        • 开启事务步骤(使用注解的方式)
          • 事务注解的一些属性
    • Resoource资源操作
          • UrlResource实现类访问url资源
          • ClassPathResourceDemo访问本地资源(项目内资源)
          • loadAndReadUrlResource访问磁盘内文件
    • 国际化:i18n
    • 数据校验
          • 通过Validator接口实现数据校验
          • 基于注解校验
          • 基于方法校验
          • 自定义校验
    • AOT

导语:感觉自己记得可能不全,所以我找了一篇优秀的笔记

(双手)奉上链接:https://lixx.cn/archives/spring6-2
https://lixx.cn/categories/spring6

spring6

1. 一些基本的概念、优势

主流,轻量级开源 框架

广义划分:以SpringFirework为核心的Spring技术栈

狭义划分:专指SpringFireWork

两大核心:Ioc和AOP

特点:

  • 非侵入式:功能组件使用注解进行标记,简洁。
  • 控制反转:自动创建对象,让我们享受资源注入。
  • 面向切面编程:在不修改源代码的基础上增强代码功能。
  • 组件化:拆分复杂应用为多个组件共同实现
  • 一站式:在集合许多依赖

2. 入门案例实现

maven聚合工程创建步骤

  • 父工程 - spring6
  • 子模块 - spring-first

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  1. 引入spring相关依赖
<dependencies><!--引入spring-context依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.1.10</version></dependency><!--测试依赖:junit--><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>5.10.2</version></dependency>
</dependencies>
  1. 创建类,定义属性和方法
package com.itchen.spring6;public class User {public void add(){System.out.println("add ...");}public static void main(String[] args) {User user = new User();user.add();}
}
  1. 按照spring要求创建一个配置文件.xml

  2. 在配置文件中创建相应的配置信息

<?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"><!--完成对User对象的创建id属性:唯一标识 (为了方便一般使用类的首字母小写)class:要创建的类的对象的全路径(包名称 + 类名称)--><bean id="user" class="com.itchen.spring6.User"></bean>
</beans>
  1. 最终测试
package com.itchen.spring6;import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class TestUser {@Testpublic void testUserObject(){// 加载spring配置文件,对象创建ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");// 获取创建的对象User user = (User)context.getBean("user");System.out.println(user);// 使用对象的调用方法进行测试user.add();}
}
  1. 输出了user对象的全路径和user的地址

分析实现过程

  1. 执行了实体类的无参数构造方法
  2. 如何返回创建的对象
    • 加载bean.xml配置文件
    • 对xml文件进行解析操作
    • 获取标签的属性值
    • 使用反射根据类的全路径创建对象
    • 对象存放在项目的一个Map集合中;格式<key,value>

3. IoC(Inversion of Control)

Spring通过loC容器来管理所有Java对象的实例化和初始化,控制对象与对象之间的依赖关系。我们将由loC容器管理的Java对象称为Spring Bean,它与使用关键字new创建的Java对象没有任何区别。

将对象的创建和对象与对象的关系都交给了容器进行管理。

基于xml的bean环境搭建

  1. 将子模块pom文件中的依赖放在父模块中(子模块依然可以调用相应的依赖)
  2. 创建资源文件(.xml)和java实体类

获取bean

  1. 实体类user.java
package com.itchen.spring6.iocxml;public class User {private String name;private Integer age;public void run(){System.out.println("run ...");}
}
  1. bean资源文件获取
    • 注意:此时的class类型的bean只能有一个
<?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 id="user" class="com.itchen.spring6.iocxml.User"></bean>
</beans>
  1. 测试获取bean的三种方式
package com.itchen.spring6.iocxml;import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class TestUser {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");// 根据对象获取beanUser user = (User)context.getBean("user");System.out.println("根据id获取bean:" + user);// 根据类型获取beanUser user2 = (User)context.getBean(User.class);System.out.println("根据类型获取bean:" + user2);// 根据id和类型获取beanUser user3 = (User)context.getBean("user", User.class);System.out.println("根据id和类型获取bean:" + user3);}
}

获取接口创建实现类

  1. 创建接口,声明需要实现的方法;在实体类中实现接口。
  2. 在bean.xml中配置相应的impl实现类
<bean id="USerDaoImpl" class="com.itchen.spring6.iocxml.bean.USerDaoImpl"></bean>

注意:这里的bean必须是唯一的。一个接口只能由一个impl实体类来实现

依赖注入 setter注入 和 构造器注入

原生方式的setter注入

先在类中定义基本的set和get方法,然后在其他类中创建类的对象,调用其setget方法来传值。

原生方式的构造器注入

先定义基本的有参构造器和无参构造器,然后在创建对象的时候在构造器中传入相对应的值。

使用bean的方式进行依赖注入步骤
  1. 创建一个类,在其中定义基本属性,生成set方法
  2. 在spring中进行配置
<bean id="book" class="com.itchen.spring6.iocxml.di.Book"><property name="bname" value="java后端开发"></property><property name="author" value="陈志伟"></property>
</bean>
  1. 测试
@Test
public void testSetter(){// 1. 加载配置文件ApplicationContext context = new ClassPathXmlApplicationContext("bean-di.xml");Book book = context.getBean("book", Book.class);System.out.println(book);
}

or

  1. 创建类,定义属性,生成有参数的构造方法
  2. 进行配置
<bean id="BookConstructor" class="com.itchen.spring6.iocxml.di.Book"><constructor-arg name="bname" value="前端开发"></constructor-arg><constructor-arg name="author" value="陈志伟"></constructor-arg>
</bean>
  1. 测试

注意:setter注入调用的是无参构造方法,而构造器注入调用的是有参构造方法

对象类型属性赋值步骤

  1. 准备工作:创建两个类(班和学生),学生中定义班的对象。定义其中的构造方法、和get、set方法
  2. 创建bean.xml(名字任意)
<!--第一种方式:引入外部bean的方式-->
<bean id="class" class="com.itchen.spring6.iocxml.ditest.Class"><property name="cname" value="241班"></property>
</bean>
<bean id="student" class="com.itchen.spring6.iocxml.ditest.Student"><property name="sname" value="Aim"></property><property name="age" value="22"></property><property name="cls" ref="class"></property>
</bean>
<!--第二种方式:引入内部bean的方式-->
<bean id="student2" class="com.itchen.spring6.iocxml.ditest.Student"><property name="sname" value="Mary"></property><property name="age" value="20"></property><!--内部bean--><property name="cls"><bean id="class2" class="com.itchen.spring6.iocxml.ditest.Class"><property name="cname" value="242班"></property></bean></property>
</bean>
<!--第三种方式:级联属性赋值-->
<bean id="cls3" class="com.itchen.spring6.iocxml.ditest.Class"><property name="cname" value="144班"></property></bean><bean id="student3" class="com.itchen.spring6.iocxml.ditest.Student"><property name="sname" value="Tom"></property><property name="age" value="28"></property><property name="cls" ref="class"></property><!--级联再赋值--><property name="cls.cname" value="141班"></property></bean>
<!--第四种方式:数组注入-->
<!--注入数组类型的属性-->
<bean id="clss" class="com.itchen.spring6.iocxml.ditest.Class"><property name="cname" value="143班"></property>
</bean>
<bean id="student" class="com.itchen.spring6.iocxml.ditest.Student"><!--普通--><property name="sname" value="Aim"></property><property name="age" value="22"></property><!--对象--><property name="cls" ref="clss"></property><!--数组--><property name="loves"><array><value>吃饭</value><value>睡觉</value><value>玩jj</value></array></property>
</bean>
<!--第五种方式:集合类型属性的注入-->
<bean id="studen1" class="com.itchen.spring6.iocxml.ditest.Student"><property name="sname" value="Aim"></property><property name="age" value="19"></property>
</bean>
<bean id="studen2" class="com.itchen.spring6.iocxml.ditest.Student"><property name="sname" value="Mary"></property><property name="age" value="19"></property>
</bean>
<bean id="studen3" class="com.itchen.spring6.iocxml.ditest.Student"><property name="sname" value="Tom"></property><property name="age" value="19"></property>
</bean>
<bean id="cls" class="com.itchen.spring6.iocxml.ditest.Class"><property name="cname" value="142班"></property><property name="stuList"><list><ref bean="studen1"></ref><ref bean="studen2"></ref><ref bean="studen3"></ref></list></property>
</bean>

注意:因为这里的包含关系变了,需要修改一下测试方法

public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("bean-diarr.xml");// 学生的对象Student stu = context.getBean("student",Student.class);stu.work();
}
<!--第六种方式:map类型属性注入-->
<!--1. 创建两个对象:用bean标签进行配置2. 注入它的普通类型的属性3. 在学生的bean中注入map集合的属性
-->
<bean id="teacher" class="com.itchen.spring6.iocxml.dimap.Teacher"><property name="tid" value="1000"></property><property name="tname" value="小李"></property>
</bean>
<bean id="student" class="com.itchen.spring6.iocxml.dimap.Student"><property name="sid" value="2000"></property><property name="sname" value="小明"></property><property name="teacherMap"><map><entry><key><value>10010</value></key><!--这里的(键值对的值)值如果是一个普通的值,可以使用value--><ref bean="teacher"></ref></entry></map></property>
</bean>
<!--第七种方式:集合类型的属性注入-->
<!--1. 创建三个对象2. 注入普通类型的属性3. 使用“util:类型” 定义4. 在学生bean中引入3.的bean
--><bean id="student" class="com.itchen.spring6.iocxml.dimap.Student"><property name="sid" value="10000"></property><property name="sname" value="张三"></property><!--注入list和map类型属性--><property name="lessonList" ref="lessonList"></property><property name="teacherMap" ref="teacherMap"></property>
</bean><util:list id="lessonList"><ref bean="lesson1"></ref><ref bean="lesson2"></ref>
</util:list>
<util:map id="teacherMap"><entry><key><value>10010</value></key><ref bean="teacher1"></ref></entry><entry><key><value>10086</value></key><ref bean="teacher2"></ref></entry>
</util:map><bean id="lesson1" class="com.itchen.spring6.iocxml.dimap.Lesson"><property name="lessonName" value="java开发"></property>
</bean>
<bean id="lesson2" class="com.itchen.spring6.iocxml.dimap.Lesson"><property name="lessonName" value="前端开发"></property>
</bean><bean id="teacher1" class="com.itchen.spring6.iocxml.dimap.Teacher"><property name="tname" value="西门庆"></property><property name="tid" value="1000"></property>
</bean>
<bean id="teacher2" class="com.itchen.spring6.iocxml.dimap.Teacher"><property name="tname" value="欧阳弧"></property><property name="tid" value="2000"></property>
</bean>

注意:第七种方式在使用的时候需要引入标签相应的命名空间

<?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:util="http://www.springframework.org/schema/util"xsi:schemaLocation="http://www.springframework.org/schema/utilhttp://www.springframework.org/schema/util/spring-util.xsdhttp://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd">

引入外部属性文件步骤

  1. 引入外部属性文件的相关依赖【pom文件】
  2. 创建一个外部的属性文件。定义数据信息:用户名、密码、地址。【.properties文件】
  3. 创建spring的配置文件,引入context的命名空间。引入属性文件,使用表达式完成注入。
<!--引入外部文件 完成数据库的信息注入-->
<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="url" value="${jdbc.url}"></property><property name="username" value="${jdbc.user}"></property><property name="password" value="${jdbc.password}"></property><property name="driverClassName" value="${jdbc.driver}"></property>
</bean>
bean的八大生命周期(重要)

可以在配置文件中【bean.xml文件】使用参数的形式制定bean对象的初始化函数和销毁函数。

  1. bean对象的创建(调用无参构造方法)
  2. 给bean对象设置相关属性
  3. bean后置处理器(初始化之前)
  4. bean对象初始化(调用制定的初始化方法)
  5. bean后置处理器(初始化之后)
  6. bean对象创建完成了,可以使用了
  7. bean对象销毁(配置制定的销毁方法)
  8. IoC容器关闭

基于xml的bean自动装配

<!--根据类型自动装配-->
<bean id="userController" class="com.itchen.spring6.iocxml.auto.Controller.UserController" autowire="byType"></bean>
<bean id="userService" class="com.itchen.spring6.iocxml.auto.Service.UserServiceImpl" autowire="byType"></bean>
<bean id="userDao" class="com.itchen.spring6.iocxml.auto.dao.UserDaoImpl" autowire="byType"></bean>
<!--根据名称自动装配-->
<bean id="userController" class="com.itchen.spring6.iocxml.auto.Controller.UserController" autowire="byName"></bean>
<bean id="userService" class="com.itchen.spring6.iocxml.auto.Service.UserServiceImpl" autowire="byName"></bean>
<bean id="userDao" class="com.itchen.spring6.iocxml.auto.dao.UserDaoImpl" autowire="byName"></bean>
<!--这时需要保证类的名字和id的名字一模一样-->

基于注解的bean自动装配(极其重要)

使用注解创建对象
  1. 引入依赖
  2. 开启组件扫描

<context:component-scan base-package="com.itchen.spring6"></context:component-scan>

  1. 被扫描的类用@component修饰;自动注入的属性用@Autowired修饰;使用注解定义bean
注解说明
@Component该注解用于描述 Spring 中的 Bean,它是一个泛化的概念,仅仅表示容器中的一个组件(Bean),并且可以作用在应用的任何层次,例如 Service 层、Dao 层等。 使用时只需将该注解标注在相应类上即可。
@Repository该注解用于将数据访问层(Dao 层)的类标识为 Spring 中的 Bean,其功能与 @Component 相同。
@Service该注解通常作用在业务层(Service 层),用于将业务层的类标识为 Spring 中的 Bean,其功能与 @Component 相同。
@Controller该注解通常作用在控制层(如SpringMVC 的 Controller),用于将控制层的类标识为 Spring 中的 Bean,其功能与 @Component 相同。

手动实现IoC

主要使用java的反射机制和注解进行实现

实现过程
  1. 创建子模块
  2. 创建测试类
  3. 创建两个注解
    • 约定注解@Bean @Di
  4. 创建bean容器的接口ApplicationContext,定义方法,返回对象
  5. 实现bean的容器接口
    • 返回对象
    • 根据包的规则加载bean(设置包的扫描规则)
手动实现一个IoC反射

loadBean步骤:

// 1. 判断当前是否是文件夹

// 2. 获取文件夹里面的所有内容

// 3. 文件夹里面为空,直接返回

// 4. 如果文件夹里面不为空
// 遍历得到的每个file对象 重复3. 4.

// 5. 如果是文件,得到包路径 + 类名称

// 6. 判断文件是否是.class类型,如果是,则去掉后缀

// 7. 如果有@Bean注解使用反射实例化

// 将实例化结果放入map集合中

package com.itchen.bean;import com.itchen.annotation.Bean;import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;public class AnnotationApplicationContext implements ApplicationContext{// 创建map集合用于创建bean的实例对象private static Map<Class,Object> beanFactory = new HashMap<>();private static String rootPath;// 返回对象@Overridepublic Object getBean(Class clazz) {return beanFactory.get(clazz);}// 设置包的扫描规则// 创建有参构造,传递包路径public static void pathDemo1(String basePackage){// 把点替换为反斜杠String packagePath = basePackage.replaceAll("\\.", "\\\\");// 获取包的绝对路径try {Enumeration<URL> dirs = Thread.currentThread().getContextClassLoader().getResources(packagePath);while(dirs.hasMoreElements()){URL url = dirs.nextElement();String filePath = URLDecoder.decode(url.getFile(), "utf-8");rootPath = filePath.substring(0, filePath.length() - packagePath.length());System.out.println(filePath);loadBean(new File(filePath));}} catch (IOException e) {throw new RuntimeException(e);} catch (ClassNotFoundException e) {throw new RuntimeException(e);}}// 包扫描过程,实例化beanprivate static void loadBean(File fileParent) throws ClassNotFoundException {// 1. 判断当前是否是文件夹if (fileParent.isDirectory()) {// 2. 获取文件夹里面的所有内容File[] childrenFiles = fileParent.listFiles();// 3. 文件夹里面为空,直接返回if (childrenFiles == null || childrenFiles.length == 0) {return;}// 4. 如果文件夹里面不为空// 遍历得到的每个file对象  重复3. 4.for (File child : childrenFiles) {if (child.isDirectory()) {loadBean(child);} else {// 5. 如果是文件,得到包路径 + 类名称String pathWithClass = child.getAbsolutePath().substring(rootPath.length() - 1);// 6. 判断文件是否是.class类型,如果是,则去掉后缀String fullName = pathWithClass.replaceAll("\\\\", ".").replace(".class", "");try {Class<?> aClass = Class.forName(fullName);// 7. 如果有@Bean注解使用反射实例化if (!aClass.isInterface()) {Bean annotation = aClass.getAnnotation(Bean.class);if (annotation != null) {Object instance = aClass.newInstance();if (aClass.getInterfaces().length > 0) {System.out.println("正在加载【" + aClass.getInterfaces()[0] + "】,实例对象是:" + instance.getClass().getName());beanFactory.put(aClass.getInterfaces()[0], instance);} else {System.out.println("正在加载【" + aClass.getName() + "】,实例对象是:" + instance.getClass().getName());beanFactory.put(aClass, instance);}}}// 将实例化结果放入map集合中}catch (Exception e){e.printStackTrace();}}}}}    
}
手动实现属性注入过程
// 1. 实例化对象在beanFactory的map集合里面
// 遍历map集合// 2. 获取所有的value值,获取每个对象的属性// 3. 遍历对象属性的数组,得到每个属性// 4. 判断是否有@Di注解// 5. 如果有,将对象注入
package com.itchen.bean;import com.itchen.annotation.Bean;
import com.itchen.annotation.Di;
import com.itchen.bean.ApplicationContext;import java.io.File;
import java.lang.reflect.Field;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;public class AnnotationApplicationContext implements ApplicationContext {//存储bean的容器private HashMap<Class, Object> beanFactory = new HashMap<>();private static String rootPath;@Overridepublic Object getBean(Class clazz) {return beanFactory.get(clazz);}/*** 根据包扫描加载bean* @param basePackage*/public AnnotationApplicationContext(String basePackage) {try {String packageDirName = basePackage.replaceAll("\\.", "\\\\");Enumeration<URL> dirs =Thread.currentThread().getContextClassLoader().getResources(packageDirName);while (dirs.hasMoreElements()) {URL url = dirs.nextElement();String filePath = URLDecoder.decode(url.getFile(),"utf-8");rootPath = filePath.substring(0, filePath.length()-packageDirName.length());loadBean(new File(filePath));}} catch (Exception e) {throw new RuntimeException(e);}// 属性的注入loadDi();}private  void loadBean(File fileParent) {if (fileParent.isDirectory()) {File[] childrenFiles = fileParent.listFiles();if(childrenFiles == null || childrenFiles.length == 0){return;}for (File child : childrenFiles) {if (child.isDirectory()) {//如果是个文件夹就继续调用该方法,使用了递归loadBean(child);} else {//通过文件路径转变成全类名,第一步把绝对路径部分去掉String pathWithClass = child.getAbsolutePath().substring(rootPath.length() - 1);//选中class文件if (pathWithClass.contains(".class")) {//    com.xinzhi.dao.UserDao//去掉.class后缀,并且把 \ 替换成 .String fullName = pathWithClass.replaceAll("\\\\", ".").replace(".class", "");try {Class<?> aClass = Class.forName(fullName);//把非接口的类实例化放在map中if(!aClass.isInterface()){Bean annotation = aClass.getAnnotation(Bean.class);if(annotation != null){Object instance = aClass.newInstance();//判断一下有没有接口if(aClass.getInterfaces().length > 0) {//如果有接口把接口的class当成key,实例对象当成valueSystem.out.println("正在加载【"+ aClass.getInterfaces()[0] +"】,实例对象是:" + instance.getClass().getName());beanFactory.put(aClass.getInterfaces()[0], instance);}else{//如果有接口把自己的class当成key,实例对象当成valueSystem.out.println("正在加载【"+ aClass.getName() +"】,实例对象是:" + instance.getClass().getName());beanFactory.put(aClass, instance);}}}} catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {e.printStackTrace();}}}}}}// 属性注入private void loadDi() {for(Map.Entry<Class,Object> entry : beanFactory.entrySet()){//就是咱们放在容器的对象Object obj = entry.getValue();Class<?> aClass = obj.getClass();Field[] declaredFields = aClass.getDeclaredFields();for (Field field : declaredFields){Di annotation = field.getAnnotation(Di.class);if( annotation != null ){field.setAccessible(true);try {System.out.println("正在给【"+obj.getClass().getName()+"】属性【" + field.getName() + "】注入值【"+ beanFactory.get(field.getType()).getClass().getName() +"】");field.set(obj,beanFactory.get(field.getType()));} catch (IllegalAccessException e) {e.printStackTrace();}}}}}
}

4. 面向切面编程

核心业务+任务日志 – > 代码冗余

解决:用代理模式将其分离(分离任务日志) ----------------- 解耦

静态代理图解

原生的方法调用

增加代理之后的方法调用

静态代理术语

代理:将非核心代码分离出来后,封装这些非逻辑代理、对象、方法

目标:被代理套用的非核心代码类、对象、方法

动态代理

原因:因为静态代理不具备代码的灵活性,所以引入了动态代理

动态代理的实现过程
package com.itchen.spring6.aop.example;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;public class ProxyFactory {// 目标对象private Object target;public ProxyFactory(Object obj){target = obj;}// 返回代理对象的方法public Object getProxy(){/*** 参数1. 类加载器* 参数2. 目标对象实现的所有接口* 参数3. 设置代理修改目标函数的方法* */ClassLoader classLoader = target.getClass().getClassLoader();Class<?>[] interfaces = target.getClass().getInterfaces();InvocationHandler invocationHandler = new InvocationHandler(){@Override/*** 参数1. 代理对象* 参数2. 需要重写目标对象中的方法啊* 参数3. 目标方法中的参数* */public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("[动态代理][日志] "+method.getName()+",参数:"+ Arrays.toString(args));Object result = method.invoke(target, args);System.out.println("[动态代理][日志] "+method.getName()+",结果:"+ result);return result;}};return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);}
}

自行补充计算器的基类和计算器接口类

// 测试类
package com.itchen.spring6.aop.example;public class TestCaculator {public static void main(String[] args) {// 1. 创建代理对象ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());Calculator proxy = (Calculator) proxyFactory.getProxy();proxy.add(1,2);proxy.mul(2,4);}
}

概念

AOP(Aspect Oriented Programming)是一种设计思想,是软件设计领域中的面向切面编程,它是面向对象编程的一种补充和完善,它以通过预编译方式和运行期动态代理方式实现,在不修改源代码的情况下,给程序动态统一添加额外功能的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

相关术语

  1. 横切关注点
    • 项目中相同的需要被提取的部分
  2. 通知(增强)
    • 需要增加的功能
    • 通知方法:横切关注点的实现
    • 通知类型:五种
  3. 切面 > 通知
    • 封装通知方法的类(eg. 一个切面类包含:前置通知、返回通知、后置通知等)
  4. 目标
    • 被代理的对象
  5. 代理
    • 向目标对象应用通知后创建代理对象
  6. 连接点
    • 能使用通知的地方
  7. 切入点
    • 实际去增强方法的位置

AOP思想综述

将特定的代码封装到切面类中,将切面类用于一个新的目标方法,最终实现 方法的增强(方法的增强好抽象呀)

基于注解方式配置AOP

通知类型及其使用
package com.itchen.spring6.aop.annoaop;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;import java.util.Arrays;@Aspect // 切面类
@Component // 在spring的ioc容器中进行管理
public class LogAspect {// 设置切入点和通知类型@Before(value = "pointCut()")public void beforeMethod(JoinPoint joinPoint){String methodName = joinPoint.getSignature().getName();String args = Arrays.toString(joinPoint.getArgs());System.out.println("Logger-->前置通知,方法名:"+methodName+",参数:"+args);}@After("execution(* com.itchen.spring6.aop.annoaop.CalculatorImpl.*(..))")public void afterMethod(JoinPoint joinPoint){String methodName = joinPoint.getSignature().getName();System.out.println("Logger-->后置通知,方法名:"+methodName);}@AfterReturning(value = "execution(* com.itchen.spring6.aop.annoaop.CalculatorImpl.*(..))", returning = "result")public void afterReturningMethod(JoinPoint joinPoint, Object result){String methodName = joinPoint.getSignature().getName();System.out.println("Logger-->返回通知,方法名:"+methodName+",结果:"+result);}@AfterThrowing(value = "execution(* com.itchen.spring6.aop.annoaop.CalculatorImpl.*(..))", throwing = "ex")public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex){String methodName = joinPoint.getSignature().getName();System.out.println("Logger-->异常通知,方法名:"+methodName+",异常:"+ex);}@Around("execution(* com.itchen.spring6.aop.annoaop.CalculatorImpl.*(..))")public Object aroundMethod(ProceedingJoinPoint joinPoint){String methodName = joinPoint.getSignature().getName();String args = Arrays.toString(joinPoint.getArgs());Object result = null;try {System.out.println("环绕通知-->目标对象方法执行之前");//目标对象(连接点)方法的执行result = joinPoint.proceed();System.out.println("环绕通知-->目标对象方法返回值之后");} catch (Throwable throwable) {throwable.printStackTrace();System.out.println("环绕通知-->目标对象方法出现异常时");} finally {System.out.println("环绕通知-->目标对象方法执行完毕");}return result;}// 重用切入点表达式@Pointcut(value = "execution(* com.itchen.spring6.aop.annoaop.CalculatorImpl.*(..))")public void pointCut(){}
}
bean配置文件
<?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:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!--开启组件的扫描--><context:component-scan base-package="com.itchen.spring6.aop.annoaop"></context:component-scan><!--开启自动代理--><aop:aspectj-autoproxy />
</beans>
测试文件
package com.itchen.spring6.aop.annoaop;import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class TestAop {@Testpublic void testAdd(){ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");Calculator calculator = context.getBean(Calculator.class);calculator.add(1,1);}
}
报错信息解决

NoSuchBeanDefinitionException:没有在实现类中加入@Component注解创建bean

重用切入点表达式

通知注解后面的参数重复书写,所以可以用注解将参数定义为一个类似宏的东西

5. 单元测试

Junit依赖自动注入方便测试

整合Junit5 和 Junit4

// 不整合的时候测试
public class TestUser {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("bean-auto.xml");UserController userController = context.getBean("userController", UserController.class);userController.addUser();}
}
// 整合Junit5
@SpringJUnitConfig(locations = "classpath:bean.xml")
public class SpringTestJunit5 {@Autowiredprivate User user;// 测试方法@Testpublic void testUser(){System.out.println(user);user.run();}
}
// 整合Junit4
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:bean.xml")
public class SpringTestJunit4 {@Autowiredprivate User user;@Testpublic void testUser4(){System.out.println(user);user.run();}
}

6. 事务

JdbcTemplate对象操作Mysql数据库(Spring事务处理前置知识)

准备环境
  1. 导入依赖
<!--spring jdbc  Spring 持久化层支持jar包-->
<dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>6.0.2</version>
</dependency>
<!-- MySQL驱动 -->
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.30</version>
</dependency>
<!-- 数据源 -->
<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.15</version>
</dependency>
<!--spring对junit的支持相关依赖-->
<dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>6.0.2</version>
</dependency><!--junit5测试-->
<dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>5.9.0</version>
</dependency>
  1. 配置jdbc.properties配置文件连接数据库
jdbc.user=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/spring?characterEncoding=utf8&useSSL=false
jdbc.driver=com.mysql.cj.jdbc.Driver
  1. 配置bean.xml配置JdbcTemplate
<?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:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!-- 导入外部属性文件 --><context:property-placeholder location="classpath:jdbc.properties" /><!-- 配置数据源 --><bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="url" value="${jdbc.url}"/><property name="driverClassName" value="${jdbc.driver}"/><property name="username" value="${jdbc.user}"/><property name="password" value="${jdbc.password}"/></bean><!-- 配置 JdbcTemplate --><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><!-- 装配数据源 --><property name="dataSource" ref="druidDataSource"/></bean>
</beans>
利用JdbcTemplate对象完成对数据库的增加、修改、删除操作

测试代码

package com.itchen.spring6.jdbc;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;@SpringJUnitConfig(locations = "classpath:beans.xml")
public class JdbcTemplateTest {@Autowiredprivate JdbcTemplate jdbcTemplate;// 添加、修改、删除操作@Testpublic void testUpdate(){// 添加数据String sql = "insert into t_emp values(null,?,?,?)";Object[] params = {"洛萨",32,"男"};
//        添加数据
//        int rows = jdbcTemplate.update(sql,params);
//        System.out.println("影响了" + rows + "行");String sql2 = "update t_emp set name=? where id=?";// 修改id为?行数据的名字字段
//        int row = jdbcTemplate.update(sql2,"666",3);
//        System.out.println("影响了" + row + "行");// 删除id为?的一行String sql3 = "delete from t_emp where id=?";
//        int row3 = jdbcTemplate.update(sql3,3);
//        System.out.println("影响了" + row3 + "行");}
}
利用JdbcTemplate对象完成对数据库的查询操作
package com.itchen.spring6.jdbc;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;import java.util.List;@SpringJUnitConfig(locations = "classpath:beans.xml")
public class jdbcTemplateTest2 {@Autowiredprivate JdbcTemplate jdbcTemplate;/*** queryForObject* */// 查询并获取数据库的第一行数据@Testpublic void testSelectObject1(){String sql = "select * from t_emp where id=?";Emp person = jdbcTemplate.queryForObject(sql, (rs, rowNum) -> {Emp emp = new Emp();emp.setId(rs.getInt("id"));emp.setName(rs.getString("name"));emp.setAge(rs.getInt("age"));emp.setSex(rs.getString("sex"));return emp;}, 1);System.out.println(person);}/*** queryForObject* */@Testpublic void testSelectObject2(){String sql = "select * from t_emp where id=?";// 利用BeanPropertyRowMapper方法自动创建对象接收数据库数据Emp emp = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Emp.class),2);System.out.println(emp);}/*** query* */@Testpublic void testSelectList(){String sql = "select * from t_emp";List<Emp> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Emp.class));System.out.println(list);}/*** queryForObject* *///查询单行单列的值@Testpublic void selectCount(){String sql = "select count(id) from t_emp";Integer count = jdbcTemplate.queryForObject(sql, Integer.class);System.out.println(count);}
}
报错信息解决

BadSqlGrammarException:没有按照规定的sql语法进行传递参数信息

事务处理

概念

eg.银行转账,要成功都成功;要失败,都失败

特性

原子性:要成功,都成功

一致性:操作前和操作后总量一致

隔离性:多个事务进行操作,对各个事务之间没有影响

持久性:提交就永久保存

声明式事务管理(基于注解实现)

准备环境(基于上面的JDBC示例进行添加,目录结构如下)

pkgwcod.png

BookController
package com.itchen.spring.tx.controller;import com.itchen.spring.tx.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;@Controller
public class BookController {@Autowiredprivate BookService bookService;// 买书的方法: 图书的id  、  用户的idpublic void buyBook(Integer bookId,Integer userId){// 调用Service方法bookService.buyBook(bookId,userId);}
}
BookDao
package com.itchen.spring.tx.dao;public interface BookDao {Integer getBookPriceByBookId(Integer bookId);void updateStock(Integer bookId);void updateUserBalance(Integer userId,Integer price);
}
BookDaoImpl
package com.itchen.spring.tx.dao;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;@Repository
public class BookDaoImpl implements BookDao{@Autowiredprivate JdbcTemplate jdbcTemplate;Integer price;@Overridepublic Integer getBookPriceByBookId(Integer bookId) {String sql = "select price from t_book where book_id=?";price = jdbcTemplate.queryForObject(sql, Integer.class, bookId);return price;}@Overridepublic void updateStock(Integer bookId) {String sql = "update t_book set stock=stock-1 where book_id=?";jdbcTemplate.update(sql,bookId);}@Overridepublic void updateUserBalance(Integer userId,Integer price) {String sql = "update t_user set balance=balance-? where user_id=?";jdbcTemplate.update(sql,price,userId);}
}
BookService
package com.itchen.spring.tx.service;public interface BookService {void buyBook(Integer bookId, Integer userId);
}
BookServiceImpl
package com.itchen.spring.tx.service;import com.itchen.spring.tx.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;@Service
public class BookServiceImpl implements BookService{@Autowiredprivate BookDao bookDao;@Overridepublic void buyBook(Integer bookId, Integer userId) {// 根据图书id查询图书的价格Integer price = bookDao.getBookPriceByBookId(bookId);// 更新图书表中的库存量bookDao.updateStock(bookId);// 更新用户余额bookDao.updateUserBalance(userId,price);}
}
TestBookTx
package com.itchen.spring.tx;import com.itchen.spring.tx.controller.BookController;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;@SpringJUnitConfig(locations = "classpath:beans.xml")
public class TestBookTx {@Autowiredprivate BookController bookController;@Testpublic void testBuyBook(){bookController.buyBook(1,1);}
}
分析

将买书一个方法作为一个大的方法在Controller中调用。然后再Service将这个方法分解成多个数据库操作。最后将数据库的各个操作在dao层进行实现。(揉碎了喂到嘴里)

问题:这里如果用户的余额不足,仍然会执行图书出库操作,但是应为没有事物的回滚,报错的步骤不会执行

开启事务步骤(使用注解的方式)
  1. 在bean中添加:开启事务的注解驱动
  2. 在业务逻辑层(Service层)添加事务注解@Transactional**【这个注解可以加在方法上,也可以加在类上】**

运行结果:在用户余额不足的情况下依然报错,但是不会执行图书出库操作

事务注解的一些属性
参数描述
readOnly是否只读(表示是否只能进行查询操作)
timeout设置超时时间(-1,表示永不超时;单位是秒)
noRollbackFor事务策略(设置哪些异常不回滚)
(见文章头连接)隔离级别:解决脏读、不可重读、虚读
(见文章头连接)传播行为:事务之间的相互调用,使用哪一个事务进行逻辑处理

脏读:两个都未提交,但是都能看见对方的修改

不可重复:一个提交了,另一个修改了没有提交的能看到修改完成之后的数据

虚读:一个提交了,另一个做完了添加没有提交之后能读到自己添加的数据

Resoource资源操作

Resource接口提供了对低级资源访问的抽象方法,接口有多个实现类供给给我们来访问低级资源

UrlResource实现类访问url资源
// 演示urlResource访问网络资源
public class UrlResourceDemo {public static void main(String[] args) {// http前缀loadUrlResource("https://www.baidu.com/");// file前缀 放在项目的根路径loadUrlResource("file:itchen.txt");}// 访问前缀httppublic static void loadUrlResource(String path){// 创建Resource接口的实现类的对象try {// 获取资源UrlResource url = new UrlResource(path);System.out.println(url.getFilename());System.out.println(url.getURI());System.out.println(url.getDescription());System.out.println(url.getInputStream().read());} catch (Exception e) {throw new RuntimeException(e);}// 获取资源信息}
}
ClassPathResourceDemo访问本地资源(项目内资源)
// 访问类路径下的资源
public class ClassPathResourceDemo {public static void main(String[] args) {loadClasspathResource("itchen.txt");}public static void loadClasspathResource(String path){// 创建的对象ClassPathResource resource = new ClassPathResource(path);System.out.println(resource.getFilename());System.out.println(resource.getDescription());// 获取文件内容try {InputStream in = resource.getInputStream();byte[] b = new byte[1024];while(in.read(b) != -1){System.out.println(new String(b));}} catch (IOException e) {throw new RuntimeException(e);}}
}
loadAndReadUrlResource访问磁盘内文件
public class FileSystemResourceDemo {public static void loadAndReadUrlResource(String path) throws Exception{//相对路径FileSystemResource resource = new FileSystemResource("itchen.txt");//绝对路径//FileSystemResource resource = new FileSystemResource("D:\\itchen.txt");// 获取文件名System.out.println("resource.getFileName = " + resource.getFilename());// 获取文件描述System.out.println("resource.getDescription = "+ resource.getDescription());//获取文件内容InputStream in = resource.getInputStream();byte[] b = new byte[1024];while(in.read(b)!=-1) {System.out.println(new String(b));}}public static void main(String[] args) throws Exception {loadAndReadUrlResource("itchen.txt");}
}

其他的实现类见文档头链接

国际化:i18n

调用不同的配置文件示例

@Test
public void test1(){ResourceBundle bundle = ResourceBundle.getBundle("itchen", new Locale("zh", "CN"));String value1 = bundle.getString("test");System.out.println(value1);
}
@Test
public void test2() {ResourceBundle bundle = ResourceBundle.getBundle("itchen", new Locale("en", "GB"));String value1 = bundle.getString("test");System.out.println(value1);
}

数据校验

通过Validator接口实现数据校验
public class TestMethod1 {public static void main(String[] args) {//创建person对象Person person = new Person();person.setName("lucy");person.setAge(-1);// 创建Person对应的DataBinderDataBinder binder = new DataBinder(person);// 设置校验binder.setValidator(new PersonValidator());// 由于Person对象中的属性为空,所以校验不通过binder.validate();//输出结果BindingResult results = binder.getBindingResult();System.out.println(results.getAllErrors());}
}

测试:

public class PersonValidator implements Validator {// 校验类型确认@Overridepublic boolean supports(Class<?> clazz) {return Person.class.equals(clazz);}// 校验逻辑@Overridepublic void validate(Object object, Errors errors) {ValidationUtils.rejectIfEmpty(errors, "name", "name.empty");Person p = (Person) object;if (p.getAge() < 0) {errors.rejectValue("age", "error value < 0");} else if (p.getAge() > 110) {errors.rejectValue("age", "error value too old");}}
}
基于注解校验
基于方法校验
自定义校验

其他的实现类见文档头链接

AOT

AOT先关概念

  1. JIT:动态编译,边运行边编译

  2. AOT:运行前编译,提前编译

pk2bEzq.md.png

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/40760.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

PyPDF2合并PDF文件的高级应用:指定合并方式

本文目录 前言一、合并PDF的高级应用1、逻辑讲解2、合并效果图3、完整代码二、异常校验1、合并过程中的错误校验前言 本文我们主要来讲解一下PyPDF2合并PDF文件的高级应用,就是指定合并方式进行合并,构建函数支持模式选择,主要不管咋折腾,其实就是不想去付费买那个PDF编辑…

PDF怎么分割成一页一页的?原来可以这么轻松

PDF怎么分割成一页一页的&#xff1f;PDF文档因其跨平台兼容性和可打印性而被广泛使用&#xff0c;但有时为了便于发送电子邮件、管理文档或保护敏感信息&#xff0c;我们需要将一个大型的PDF文件分割成多个小文件。幸运的是&#xff0c;分割PDF文件并不复杂。下文中就介绍了三…

webp2jpg网页在线图片格式转换源码

源码介绍 webp2jpg-免费在线图片格式转化器, 可将jpeg、jpg、png、gif、 webp、svg、ico、bmp文件转化为jpeg、png、webp、webp动画、gif文件。 无需上传文件&#xff0c;本地即可完成转换! 源码特点&#xff1a; 无需上传&#xff0c;使用浏览器自身进行转换批量转换输出we…

easyexcel使用小结-未完待续

官网&#xff1a;https://easyexcel.opensource.alibaba.com/docs/current/ <dependency><groupId>com.alibaba</groupId><artifactId>easyexcel</artifactId><version>4.0.1</version></dependency>一、读 1.1简单读 Getter…

鸿蒙小案例-自定义键盘

一个自定义键盘 效果 完成简单的26键中英文输入 使用&#xff1a; Entry Component struct IndexInput {State text: string inputController: TextInputController new TextInputController()//自定义键盘关闭事件hideClick(){this.inputController.stopEditing()}//自定义…

软件测评机构:关于软件验收测试作用与实施步骤全解析

软件验收测试是指在软件项目交付给用户之前进行的一系列测试活动&#xff0c;其主要目的是验证软件是否符合用户需求和设计规范&#xff0c;以确保软件的质量和稳定性。 软件验收测试在软件开发生命周期的最后阶段进行&#xff0c;起到了至关重要的作用。它能够帮助客户确认软…

c++:动态内存变量

典型的C面向对象编程 元素 (1)头文件hpp中类的定义 (2)源文件cpp中类的实现&#xff08;构造函数、析构函数、方法&#xff09; (3)主程序 案例 (1)用C来编程“人一天的生活” (2)“人”的属性&#xff1a;name、age、male (3)“人”的方法&#xff1a;eat、work(coding/shop…

【网络安全学习】漏洞利用:BurpSuite的使用-03-枚举攻击案例

如何使用BurpSuite进行枚举攻击 1.靶场选择 BurpSuite官方也是有渗透的教学与靶场的&#xff0c;这次就使用BurpSuite的靶场进行练习。 靶场地址&#xff1a;https://portswigger.net/web-security 登录后如下图所示&#xff0c;选择**【VIEW ALL PATHS】**&#xff1a; 找…

PHP基础教程——总结W3school

1、<?php ?> 2、$ 声明变量 3、变量大小写敏感 关键字&#xff08;if、else、echo&#xff09;和用户定义的类、函数大小写不敏感 4、三种注释 // # /* */ 5、echo "<br>"; 换行 6、global(关键字) 函数内访问全局变量 $GLOBALS[index] …

经典链表算法题:找到环的入口。清晰图示推导出来

Leetcode题目链接 原理 重画链表如下所示&#xff0c;线上有若干个节点。记蓝色慢指针为 slow&#xff0c;红色快指针为 fast。初始时 slow 和 fast 均在头节点处。 使 slow 和 fast 同时前进&#xff0c;fast 的速度是 slow 的两倍。当 slow 抵达环的入口处时&#xff0c;如…

【公益案例展】四川农担x中电金信——大数据智能风控平台建设

‍ 中电金信公益案例 本项目案例由中电金信投递并参与数据猿与上海大数据联盟联合推出的 #榜样的力量# 《2024中国数据智能产业最具社会责任感企业》榜单/奖项”评选。 大数据产业创新服务媒体 ——聚焦数据 改变商业 1、外部经济环境带来的挑战 近几年经济发展和市场需求的挑…

【C语言】—— 文件操作(下)

【C语言】—— 文件操作&#xff08;下&#xff09; 前言&#xff1a;五、文件的顺序读写5.1、 顺序读写函数介绍5.2、 f p u t c fputc fputc 函数5.3、 f g e t c fgetc fgetc 函数5.4、 f p u t s fputs fputs 函数5.5、 f g e t s fgets fgets 函数5.6、 f p r i n t f…

2024 年 亚太赛 APMCM (C题)中文赛道国际大学生数学建模挑战赛 | 量子计算的物流配送 | 数学建模完整代码+建模过程全解全析

当大家面临着复杂的数学建模问题时&#xff0c;你是否曾经感到茫然无措&#xff1f;作为2022年美国大学生数学建模比赛的O奖得主&#xff0c;我为大家提供了一套优秀的解题思路&#xff0c;让你轻松应对各种难题&#xff01; 完整内容可以在文章末尾领取&#xff01; 该段文字…

C++内存管理(候捷)第一讲 笔记

内存分配的每一层面 applications可以调用STL&#xff0c;里面会有allocator进行内存分配&#xff1b;也可以使用C 基本工具primitives&#xff0c;比如new, new[], new(), ::operator new()&#xff1b;还可以使用更底层的malloc和free分配和释放内存。最底层的是系统调用&…

Maven Archetype 自定义项目模板:高效开发的最佳实践

文章目录 前言一、Maven Archetype二、创建自定义 Maven Archetype三、定制 Archetype 模板四、手动创建 Archetype 模板项目五、FAQ5.1 如何删除自定义的模板5.2 是否可以在模板中使用空文件夹 六、小结推荐阅读 前言 在软件开发中&#xff0c;标准化和快速初始化项目结构能够…

14-20 Vision Transformer用AI的画笔描绘新世界

概述 毫无疑问,目前最受关注且不断发展的最重要的主题之一是使用人工智能生成图像、视频和文本。大型语言模型 (LLM) 已展示出其在文本生成方面的卓越能力。它们在文本生成方面的许多问题已得到解决。然而,LLM 面临的一个主要挑战是它们有时会产生幻觉反应。 最近推出的新模…

分布式计算、异构计算与算力共享

目录 算力 算力共享的技术支撑 云计算技术 边缘计算技术 区块链技术 分布式计算、异构计算与算力共享 分布式计算:计算力的“集团军作战” 异构计算:计算力的“多兵种协同” 算力共享:计算力的“共享经济” 深入融合,共创计算新纪元 算力共享对科研领域的影响 …

openmetadata1.3.1 自定义连接器 开发教程

openmetadata自定义连接器开发教程 一、开发通用自定义连接器教程 官网教程链接&#xff1a; 1.https://docs.open-metadata.org/v1.3.x/connectors/custom-connectors 2.https://github.com/open-metadata/openmetadata-demo/tree/main/custom-connector &#xff08;一&…

Matplotlib 文本

可以使用 xlabel、ylabel、text向图中添加文本 mu, sigma 100, 15 x mu sigma * np.random.randn(10000)# the histogram of the data n, bins, patches plt.hist(x, 50, densityTrue, facecolorg, alpha0.75)plt.xlabel(Smarts) plt.ylabel(Probability) plt.title(Histo…

git 还原被删除的分支

在多人项目开发中&#xff0c;有一次碰到忘记合并到master分支了&#xff0c;直接就把开发分支给删除了&#xff0c;现在记录下怎么还原被删除的分支 必须保证删除的分支之前已经被推送到了远程仓库 # 找出被删除分支的最后一个提交的哈希值 git reflog show# 找到提交哈希值…