Spring框架

第9章 Spring的数据库编程 本章主要讲解了Spring的数据库编程。首先介绍了Spring JDBC,包括JdbcTemplate概述和Spring JDBC的配置;然后讲解了JdbcTemplate的增删改查操作,包括excute()方法、update()方法和query()方法;接着讲解了Spring事务管理概述,包括事务管理的核心接口和事务管理的方式;最后讲解了两种实现声明式事务管理的方式,基于XML方式的声明式事务和基于注解方式的声明式事务。 阅读详情

视频来自:尚硅谷Spring框架

核心内容有:IOC、AOP、JdbcTemplate、事务管理

1. Spring

概述:

  • Spring是轻量级的开源的JavaEE框架
  • Spring可以解决企业开发的复杂性
  • 拥有IOC和Aop两个核心部分
    • IOC:控制反转,把创建对象的过程交给Spring进行管理
    • Aop:面向切面,不修改源代码进行功能增强

优点:

  • IOC方便解耦,简便开发
  • AOP不改变源代码,增加其功能
  • 方便程序测试
  • 方便其他框架的整合
  • 降低API的开发难度

下载配置:

下载Spring5 下载GA版本(稳定版本):https://repo.spring.io/release/org/springframework/spring/

下载之后压缩——>libs内是jar包——>导入spring包

2. IOC容器

​ 什么是IOC:控制反转,把对象创建和对象之间的调用过程,交给Spring进行管理;目的为了使耦合度降低。

demo:实现IOC创建对象
@Test
    public void UserTest() {
        //加载Spring配置文件
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("bean.xml");
        //获取配置创建对象
        User user = context.getBean("com.zju.User", User.class);
        user.add();
    }

2.1 IOC底层原理

  • xml解析、工厂模式、反射

​ 容器相对于对象工厂,通过读取配置文件,以反射(反射相当于从字节码文件中获取类的信息)创建对象。

第一步:xml配置文件,配置创建的对象

<bean id="dao" class"com.zju.UserDao"></bean>

第二步:创建工厂类(解耦合,只需要改配置文件)

2.2 IOC操作接口

IOC思想基于IOC容器完成,IOC容器底层就是对象工厂

Spring提供IOC容器实现的两种方式(两个接口):

  • BeanFactory:Spring 内部的使用接口,不提供开发人员进行使用。

    *加载配置文件时不会创建对象,使用时才会

  • ApplicationContext:BeanFactory 接口的子接口,提供更多更强大的功能,一般由开发人员进行使用。

    *加载配置文件时候就会创建对象(耗时操作在服务器启动时完成,慢启动快响应)

    • ClassPathXmlApplicationContext:实现类,写src下文件路径
    • FileSystemXmlApplicationContext:实现类,写磁盘全路径
//加载Spring配置文件
ApplicationContext context = 
    new ClassPathXmlApplicationContext("bean.xml");
//获取配置创建对象
User user = context.getBean("com.zju.User", User.class);

2.3 IOC操作Bean管理(基于xml方式)

Bean管理:Spring创建对象,Spring注入属性

2.3.1 基于xml方式创建对象

(1)使用bean标签添加对应属性即可实现对象创建

<bean id="dao" class"com.zju.UserDao"></bean>

​ id:获取对象的唯一标识

​ class:类全路径

(2)默认执行无参构造方法完成对象创建

2.3.2 xml方式注入基本属性

DI:依赖注入,就是注入属性。是IOC的一种具体实现。

​ 1.第一种方式:使用set方法注入

  • 创建类,定义属性和对应的set方法
  • 在spring配置文件进行对象创建和属性注入
<bean id="user" class="com.zju.User">
    <!--使用property完成属性注入,
            name:类里面属性名称
            value:注入的值
        -->
    <property name="name" value="fkd"></property>
    <property name="city" value="NingBo"></property>
</bean>

​ 2.第二种方式:使用有参构造注入

  • 创建类,定义属性,创建属性对应有参构造方法
  • 在Spring配置文件中进行配置
<bean id="orders" class="com.zju.Orders">
	<constructor-arg name="oname" value="电脑"></constructor-arg>
	<constructor-arg name="address" value="China"></constructor-arg>
</bean>

​ 3.p名称空间注入:(底层也是set方法注入)

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       
       xmlns:p="http://www.springframework.org/schema/p"
          <bean id="book" class="com.atguigu.spring5.Book" p:bname="九阳神功" p:bauthor="无名氏">
</bean>

2.3.3 xml注入其他类型属性

​ 1.字面量(属性初始值)

  • null值
<property name = "address">
	<null/>
</property>
  • 包含特殊符号
<!--1.把<>转义为&lt;&gt;
	2.把带特殊符号的内容写到CDATA(IDEA输入CD)
-->
<property name = "address">
    <value><![CDATA[<<南京>>]]></value>
</property>

​ 2.注入外部bean

  • 建立两个类
public class UserService {//service类

    //创建UserDao类型属性,生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("service add...............");
        userDao.update();//调用dao方法
    }
}

public class UserDaoImpl implements UserDao {//dao类

    @Override
    public void update() {
        System.out.println("dao update...........");
    }
}
  • Spring注入,此时的属性是对象,要用ref
<!--首先分别创建两个类对象,再注入对象属性-->
<bean id="userService" class="com.zju.service.UserService">
    <!--注入userDao对象
        name属性:类里面属性名称
        ref属性:创建userDao对象bean标签id值
    -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>

<bean id="userDaoImpl" class="com.zju.dao.UserDaoImpl"></bean>

​ 3.注入内部bean

  • 建立两个类,部门和员工,一对多
//部门类
public class Dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }
}

//员工类
public class Emp {
    private String ename;
    private String gender;
    //员工属于某一个部门,使用对象形式表示
    private Dept dept;
    
    public void setDept(Dept dept) {
        this.dept = dept;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
}
  • 通过spring配置
<bean id="emp" class="com.zju.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--设置对象类型属性-->
    <property name="dept">
        <bean id="dept" class="com.zju.bean.Dept">
            <property name="dname" value="安保部"></property>
        </bean>
    </property>
</bean>

​ 通过外部bean注入方式也可达成相同效果,根据bean的相对位置区分内外部bean

​ 4.注入属性级联赋值

方法一:通过得外部对象bean创建赋值,再注入到内部

<bean id="emp" class="com.zju.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>

</bean>
<bean id="dept" class="com.zju.bean.Dept">
    <property name="dname" value="财务部"></property>
</bean>

方法二:通过先注入外部对象,再在内部给该对象注入属性

​ 此时在emp类中要生成getDept()方法,因为dept.dname需要反射获取

<bean id="emp" class="com.zju.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>
	<property name="dept.dname" value="技术部"></property>
</bean>
<bean id="dept" class="com.zju.bean.Dept"></bean>

​ 5. 注入数组/集合属性

​ Stu类中选了多门课String[] courses/List list/Set/Map<String, String> map,生成set方法。

  • 调用对象模板
//加载xml配置
ApplicationContext context =
	new ClassPathXmlApplicationContext("bean1.xml");
//获取对象
类名 对象名 = context.getBean("对象名", 类名.class);

(1)注入数组类型属性

<property name="courses">
    <array>
        <value>java课程</value>
        <value>数据库课程</value>
    </array>
</property>

(2)注入List集合类型属性

<!--list类型属性注入-->
<property name="list">
    <list>
        <value>张三</value>
        <value>小三</value>
    </list>
</property>

(3)注入Set集合属性

!--set类型属性注入-->
<property name="sets">
    <set>
        <value>MySQL</value>
        <value>Redis</value>
    </set>
</property>

(4)注入map集合属性

<!--map类型属性注入-->
<property name="maps">
    <map>
        <entry key="JAVA" value="java"></entry>
        <entry key="PHP" value="php"></entry>
    </map>
</property>

注意点:

1.在集合里面设置对象类型值 List courseList

<bean id="stu" class="com.zju.collectiontype.Stu">
    <property name="courseList">
        <list>
            <!--bean属性放入外部id值-->
        	<ref bean="course1"></ref>
            <ref bean="course2"></ref>
        </list>
    </property>
</bean>
<!--外部创建多个course对象-->
<bean id="course1" class="com.zju.Collectiontype.Course">
	<property name="cname" value="Spring5"></property>
</bean>

<bean id="course2" class="com.zju.Collectiontype.Course">
	<property name="cname" value="SpringMVC"></property>
</bean>

2.把集合注入部分提取出来

  • 使用util的名称空间注入
<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">   //修改部分
    <!--1.提取list集合类型公共部分-->
    <util:list id="bookList">
        <value>斗破苍穹</value>
        <value>斗罗大陆</value>
        <value>吞噬星空</value>
    </util:list>
    <!--2.公共部分注入使用-->
    <!--需要注入的类-->
    <bean id="book" class="com.zju.Book">
        <property name="list" ref="bookList"></property>
    </bean>
</beans>

2.4 工厂bean

spring有两种类型,一种是上面的普通bean,另一种是工厂bean

  • 普通bean:在配置文件中,定义的bean类型就是返回类型
  • 工厂bean:在配置文件中定义bean类型可以和返回类型不一样
  • 第一步:创建类,这个类作为工厂bean,实现接口FactoryBean
  • 第二步:实现接口方法,在getObject()方法中定义返回的bean类型
public class MyBean implements FactoryBean<Course> {

    //定义返回bean的类型
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }
    @Override
	public Class<?> getObjectType() {
		return null;
	}
	@Override
	public boolean isSingleton() {
		return false;
	}
}

配置xml:

<bean id="myBean" class="com.zju.factorybean.MyBean">
</bean>

此时调用course类:

ApplicationContext context = 
    new ClassPathXmlApplicationContext("bean.xml");
Course course = context.getBean("myBean", Course.class);

2.5 bean作用域

  • 在Spring里,设置创建bean实例是单实例(只有一个对象)还是多实例(每次都建一个新对象)

  • 在Spring里,默认情况下,bean是单实例对象(加载配置文件时默认已经创建对象)

  • 如何设置单实例还是多实例?

设置bean标签中的属性scope:singleton(单实例)、prototype(多实例)、request、session

<bean id="book" class="com.zju.Book" scope="prototype">
    <property name="list" ref="bookList"></property>
</bean>

区别:

  • 设置singleton时,在spring加载配置文件时就会创建单实例对象
  • 设置prototype时,在调用getBean方法时才会创建多实例对象

2.6 bean生命周期

生命周期:从对象创建到销毁的过程

1.bean生命周期:

1.通过构造器创建bean实例(无参构造)

2.注入bean属性和其他bean引用(调用set方法)

(传递bean实例给bean后置处理器的方法)postProcessBeforeInitialization

3.调用bean的初始化的方法(需要进行配置)

(传递bean实例给bean后置处理器的方法)postProcessAfterInitialization

4.bean可以使用了(对象获取到了)

5.当容器关闭的时候,调用bean的销毁方法(需要进行配置销毁的方法)

创建-DI(注入属性)-初始化-使用-销毁

演示过程:

配置xml,指定初始化方法和销毁方法

<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="oname" value="手机"></property>
</bean>
public class Orders {

    //无参数构造
    public Orders() {
        System.out.println("第一步 执行无参数构造创建bean实例");
    }

    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用set方法设置属性值");
    }

    //创建执行的初始化的方法
    public void initMethod() {
        System.out.println("第三步 执行初始化的方法");
    }

    //创建执行的销毁的方法
    public void destroyMethod() {
        System.out.println("第五步 执行销毁的方法");
    }
}
 @Test
public void testBean3() {
    //        ApplicationContext context =
    //                new ClassPathXmlApplicationContext("bean4.xml");
    ClassPathXmlApplicationContext context =
        new ClassPathXmlApplicationContext("bean4.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("第四步 获取创建bean实例对象");
    System.out.println(orders);

    //手动让bean实例销毁
    context.close();
}

2.bean的后置处理器

位于bean生命周期初始化方法执行的前后

在xml配置后,会对当前xml中的所有bean都添加后置处理器

  • 创建类,实现接口BeanPostProcessor
public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}
<!--配置后置处理器-->
<bean id="myBeanPost" class="com.zju.bean.MyBeanPost"></bean>

在这里插入图片描述

2.7 xml自动装配

​ 自动装配:根据指定装配规则(属性名称或者属性类型),Spring自动将匹配属性值进行注入。

  • 根据属性名称:autowire=“byName”注入值的bean的id和属性名一致
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
  <!--<property name="dept" ref-id="dept"></property>-->
</bean>

<bean id="dept"class="com.atguigu.spring5.autowire.Dept"></bean>
  • 根据属性类型:autowire=“byType” 注入bean的class与属性类型一致
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">
</bean>

<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
<bean id="dept1" class="com.atguigu.spring5.autowire.Dept"></bean>

此时,多个同源类型会报错

2.8 外部属性文件

配置德鲁伊连接池:

  • 首先引入jar包

  • 创建外部属性文件,properties格式文件,写数据库信息

//左边随便写
prop.driverClass=com.mysql.cj.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/fkddatabase
prop.userName=root
prop.password=123456
  • 把外部properties属性文件引入到Spring配置文件中

引入context命名空间

在这里插入图片描述

  • 在Spring配置文件使用标签引入外部属性文件
<!--引入外部属性文件,classPath是src路径-->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${prop.driverClass}"></property>
    <property name="url" value="${prop.url}"></property>
    <property name="username" value="${prop.userName}"></property>
    <property name="password" value="${prop.password}"></property>
</bean>

2.9 IOC操作Bean管理(基于注解)

注解是什么?

(1) 注解是代码特殊标记,格式:@注解名称(属性名称=属性值,属性名称=属性值)
(2) 可作用在类, 方法,属性上面
(3) 注解目的:简化xml配置

Spring针对Bean管理中创建对象提供的注解:

@Component: 普通的注解
@Service :业务逻辑层以及Service层
@Controller: web层
@Repository :dao层即持久层

功能是一样的,都可以用来创建对象,只不过把每个对象用在不同地方,以便查看

1. 基于注解方式实现对象创建:

  • 第一步:引入额外的aop依赖jar包
  • 第二步:开启组件扫描(扫描包,寻找注解),使用context的名称空间(同上)
<!--开启组件扫描
 1 如果扫描多个包,多个包使用逗号隔开
 2 扫描包上层目录
-->
<context:component-scan base-package="com.zju"></context:component-scan>

开启组件扫描详细配置:

以上扫描的是包中全注解,可以自定义扫描范围

use-default-filters=“false” 表示现在不使用默认 filter,自己配置 filter

context:include-filter ,设置扫描哪些内容

type只扫描这种注解类

expression表示扫描的为该注解类

context:exclude-filter: 设置哪些内容不进行扫描

实例一:只扫描包下Controller注解

<context:component-scan base-package="com.zju" use-defaultfilters="false">
 <context:include-filter type="annotation"

                         expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
  • 第三步:创建类,在类上添加创建对象注解(四选一)
    • 在注解里面value属性值可以省略不写,默认值是类名称,改首字母小写
//UserService -- userService
//@Component(value = "userService")  //<bean id="userService" class=".."/>
@Component
public class UserService {
	public void add() {
        System.out.println("service add......."+name);
        userDao.add();
    }
}

2. 基于注解方式实现属性注入:

@Autowired:根据属性类型进行自动装配

第一步:给service和dao类分别添加创建对象注解

第二步:在service注入dao对象,在service类添加dao类型属性,在属性上面使用注解

@Service
public class UserService {
    //定义dao类型属性
    //不需要添加set方法,已经封装了
    //根据类型注入,会自动寻找实现类
    @Autowired
    private UserDao userDao;
    
    public void add(){
        userDao.add();
        System.out.println("service add...");
    }
}

@Qualifier:根据属性名称进行注入

@Qualifier注解和@Autowired配合一起使用,当有多个实现类时

@Autowired  //根据类型进行注入
@Qualifier(value = "userDaoImpl") //根据名称进行注入
private UserDao userDao;

@Resource:可以根据类型注入,也可以根据名称注入

​ 名称默认是类名称改首字母小写

//@Resource 根据类型注入
@Resource(name = "userDaoImpl1")  //根据名称进行注入
private UserDao userDao;

是javax包中的,不推荐使用

@value:注入普通类型

@Value(value = "abc")
private String name;

2.10 完全注解开发

1.创建配置类,替代xml配置文件进行组件扫描

@Configuration //作为配置类,替代xml配置文件
@ComponentScan(basePackages = {"com.zju"})
public class SpringConfig {

}

2.加载配置类

//加载Spring配置类
ApplicationContext context =
    new AnnotationConfigApplicationContext(SpringConfig.class);
//创建对象
UserService userService = context.getBean("userService", UserService.class);
userService.add();

3.AOP

  • Aop为面向切面,不修改源代码进行功能增强
  • 可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高开发的效率

回顾下静态代理和动态代理:

  • 静态代理模式:定义接口,核心类和代理类都实现该接口方法。代理类在构造方法中引入核心类对象,并在方法中调用。
    • 弊端:一个代理类只为一个接口服务,耦合严重
  • 动态代理模式:根据加载到内存之中的被代理类,在程序运行期间确定并动态创建代理类。能为所有功能一致的业务操作接口提供有统一的代理操作

举例实现:

在这里插入图片描述

package com.zju;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author godfu
 * @Date:2022/3/25-10:32
 */
interface Huaman{

    String getBelief();

    void eat(String food);
}
//被代理类
class SuperMan implements Huaman{

    @Override
    public String getBelief() {
        return "I believe I can fly";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}

/**
 * 动态代理的问题:如何根据加载到内存中的代理类,动态创建一个代理类及其对象?
 * 在代理类对象调用方法时,如何动态调用被代理类的同名方法?
 */
class ProxyFactory{
    /**
     * 传入被代理对象调用此方法返回代理类对象,解决问题一
     * @param obj 被代理类对象
     * @return 代理类类型
     */
    public static Object getProxyInstance(Object obj){
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        //告诉代理类,被代理类是哪个类加载器加载,实现了哪些接口
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),handler);
    }
}

class MyInvocationHandler implements InvocationHandler{
    //需要使用被代理类的对象进行赋值
    private Object obj;

    public void bind(Object obj){
        this.obj = obj;
    }

    //当我们通过代理类对象,调用方法a时,就会自动调用如下的方法:invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //method:此方法为被代理类的方法,也就是代理类要调用的方法
        Object returnValue = method.invoke(obj, args);
        //方法返回值
        return returnValue;
    }
}

public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //生成代理类
        Huaman proxyInstance = (Huaman) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时,会自动调用被代理类中同名的方法
        proxyInstance.eat("hamburger");
    }
}

运行结果:

=====通用方法一=====
我喜欢吃hamburger这是新功能哦(可以更换)
=====通用方法二=====

在这里插入图片描述


3.1 底层原理

底层使用的是动态代理,Spring5已经进行了封装

  • 有接口的情况,使用JDK动态代理

创建接口实现类的代理对象,增强类的方法

在这里插入图片描述

  • 没有接口情况,使用CGLIB动态代理

创建子类的代理对象,增强类的方法

在这里插入图片描述

3.2 JDK动态代理

动态代理主要涉及两个类:

  • newProxyInstance方法创建代理对象
//loader:被代理类的类加载器
//interfaces:被代理类实现的接口
//InvocationHandler:一个调用程序处理器,写增强的方法
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h);
  • invoke方法
//obj指被代理类,method是被代理的方法,args为该方法的参数数组
public Object invoke(Object obj,Method method, Object[] args)

演示动态代理过程:(同上)

  • 创建接口UserDao和实现类UserDaoImpl
  • 使用Proxy类创建接口代理对象
/**
 * UserDao的代理类,进行功能扩充
 */
public class JdkProxy {

    public static void main(String[] args) {

        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(JdkProxy.class.getClassLoader(),interfaces,new UserDaoHandler(userDao));
        dao.add();
    }
}
class UserDaoHandler implements InvocationHandler{
    private Object obj;

    public UserDaoHandler(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("预处理");
        Object returnValue = method.invoke(obj, args);
        System.out.println("处理后");
        return returnValue;
    }
}

代码执行结果: 在这里插入图片描述

3.3 AOP相关术语

  • 连接点:类中可以被增强的方法

  • 切入点:类中实际被增强的方法,称为切入点

  • 通知(增强):实际增强的逻辑部分称为通知。

    • 前置通知:要增强的方法之前执行
    • 后置通知:方法之后执行
    • 环绕通知:方法前后都执行
    • 异常通知:当方法出现异常执行
    • 最终通知:有无异常都执行,类似finally
  • 切面:是动作。把通知应用到切入点的过程

3.4 AOP操作

3.4.1准备工作

  • Spring框架一般都是基于AspectJ实现AOP操作,可以通过xml或注解方式(使用)实现
  • 需要在项目工程里引入AOP相关依赖

切入点表达式:(指定对类中方法进行增强)

语法结构: execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )

举例几个语法结构的例子
举例 1:对 com.zju.dao.BookDao 类里面的 add 进行增强
execution(* com.zju.dao.BookDao.add(..))

举例 2:对 com.zju.dao.BookDao 类里面的所有的方法进行增强
execution(* com.zju.dao.BookDao.* (..))

举例 3:对 com.zju.dao 包里面所有类,类里面所有方法进行增强
execution(* com.zju.dao.*.* (..))

3.4.2 AspectJ注解操作

1.在Spring配置文件中,开启注解扫描

<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/beans 	http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!-- 开启注解扫描 -->
    <context:component-scan base-package="com.zju.aopanno"></context:component-scan>

    <!-- 开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

2.使用注解创建被增强类User和增强的类UserProxy对象,在增强类上添加注解@Aspect

@Component
public class User{
    public void add(){
        System.out.println(add...);
    }
}
@Component
@Aspect //生成代理对象
public class UserProxy{
    //前置通知
    @Before
    public void before(){
        System.out.println("before...");
    }
}

3.在Spring配置文件中开启生成代理对象

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>,主要是查找注解@Aspect

4.配置不同的通知

在增强类里面,在作为通知方法上面添加通知类型注解,使用切入点表达式

//增强的类
@Component
@Aspect  //生成代理对象
@Order(3)
public class UserProxy {

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.zju.aopanno.User.add(..))")
    public void before() {
        System.out.println("before.........");
    }

    //后置通知(返回通知),返回结果之后执行
    @AfterReturning(value = "execution(* com.zju.aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }

    //最终通知(无论是否异常都输出)
    @After(value = "execution(* com.zju.aopanno.User.add(..))")
    public void after() {
        System.out.println("after.........");
    }

    //异常通知,没异常不输出
    @AfterThrowing(value = "execution(* com.zju.aopanno.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }

    //环绕通知
    @Around(value = "execution(* com.zju.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");

        //被增强的方法执行
        proceedingJoinPoint.proceed();

        System.out.println("环绕之后.........");
    }
}
ApplicationContext context =
    new ClassPathXmlApplicationContext("bean.xml");
User user = context.getBean("user", User.class);
user.add();//调用被代理对象会自动执行
  • 相同切入点的抽取@Pointcut(value="execution( com.zju.aopanno.User.add(…))")*
//代理类
@Component
@Aspect
public class UserProxy {
    @Pointcut(value = "execution(* com.zju.proxyAnno.User.add(..))")
    public void pointCut(){

    }
    @Before(value = "pointCut()")
    public void before(){
        System.out.println("before...");
    }
}
  • 有多个增强类多同一个方法进行增强,设置增强类优先级

在增强类上面添加注解 @Order(数字类型值),数字类型值越小优先级越高

@Component
@Aspect
@Order(1)

3.4.3 完全注解开发

  • 生成配置类,代替xml配置
@Configuration //作为配置类,替代xml配置文件
@ComponentScan(basePackages = {"com.zju.proxyAnno"})//开启组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启Aspect生成代理对象,默认是true
public class SpringConfig {
}

3.4.4 AspectJ配置文件

1.创建两个类,增强类和被增强类,创建方法

public class Book {
    public void buy() {
        System.out.println("buy.............");
    }
}
public class BookProxy {
    public void before() {
        System.out.println("before.........");
    }
}

2.在spirng配置文件中创建两个类对象、在spring配置文件中配置切入点

<!--创建对象-->
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>

<!--配置aop增强-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
    <!--配置切面-->
    <aop:aspect ref="bookProxy">
        <!--增强作用在具体的方法上-->
        <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>

4. Jdbc Template

JdbcTemplate是Spring框架对JDBC进行封装,更方便实现对数据库操作

4.1 准备工作

  • 引入依赖,在Spring配置文件配置数据库连接池

在这里插入图片描述

  • 配置JdbcTemplate对象,注入DataSource
<!-- JdbcTemplate对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入dataSource-->
    <property name="dataSource" ref="dataSource"></property>
</bean>
  • 开启组件扫描,注解方式在dao注入JdbcTemplate,在service注入dao

@Autowired按类型注入,可以与@Qualifier按名称注入配合使用

@Resourse默认按名称注入,可同时指定名称name和类型type

IDEA不建议使用@Autowired

@Service
public class UserService {
    //注入dao
    @Resource
    private UserDao userDao;
}
@Repository
public class UserDaoImpl implements UserDao {

    @Resource
    private JdbcTemplate jdbcTemplate;

4.2 数据库添加

  • 创建数据库表和数据库实体类

  • 编写service和dao进行数据库添加操作

    • 在service层和dao层添加add(User user)方法
    • 在dao层调用JdbcTemplate对象里面的jdbcTemplate.update(String sql, Object ... args)方法
@Repository
public class UserDaoImpl implements UserDao {
    @Resource
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(User user) {
        String sql = "insert into t_user values(?,?,?)";
        int update = jdbcTemplate.update(sql, null, user.getUserName(), user.getStatus());
        System.out.println(update);
    }
}

测试类:

@Test
public void testAdd(){
    ApplicationContext context =
        new ClassPathXmlApplicationContext("jdbc.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.addUser(new User(null,"fkd", "躺平"));
}

4.3 数据库修改与删除

方法同上:

  • 数据库修改:
@Override
public void update(User user) {
    String sql = "update t_user set userName=?, status=? where user_id=?";
    int update = jdbcTemplate.update(sql,user.getUserName(),user.getStatus(),user.getUserId());
    System.out.println(update);
}
  • 数据库删除
@Test
public void testDelete(){
    ApplicationContext context =
        new ClassPathXmlApplicationContext("jdbc.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.deleteUser(2);
}

4.4 数据库查询

1.查询返回某个值:

  • 使用JdbcTemplate实现查询返回某个值:jdbcTemplate.queryForObject(String sql, Class<T> requiredType)
    • 第二个参数是返回类型的Class
@Override
public int selectCount() {
    String sql = "select count(*) from t_user";
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    return count.intValue();
}

2.查询返回对象:

  • 使用JdbcTemplate实现查询返回对象:jdbcTemplate.queryForObject(String sql, RowMapper<T> rowMapper, Object ... args)
    • 第二个参数RowMapper,是接口,返回不同类型对象。使用接口实现类BeanPropertyRowMapper<User>(User.class)能够将查询到的数据封装到对象中。(类似BeanHandler)
    • 第三个参数是占位符的值
@Override
public User findUserInfo(Integer id) {
    String sql = "select `user_id` userId, `userName`, `status` form t_user where user_id = ?";
    User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), id);
    return user;
}

注意:实体类User必须声明无参构造>

3.查询返回集合:

  • 调用jdbcTemplate.query(String sql, RowMapper<T> rowMapper, Object... args)
  • 会自动将查询到的数据封装到对象中,然后存到集合里
@Override
public List<User> findAllUser() {
    String sql = "select `user_id` userId, `userName`, `status` form t_user";
    List<User> userList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
    return userList;
}

4.5 数据库批量操作

1.批量添加:jdbcTemplate.batchUpdate(String sql, List<Object[]> batchArgs)

  • 第二个参数batchArgs:List集合,每项是记录数据构成的对象数组
  • 方法底层会遍历,逐条添加
//批量添加
@Override
public void batchAddUser(List<Object[]> batchArgs) {
    String sql = "insert into t_user values(?,?,?)";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}
//批量添加测试
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"2","sk","a"};
Object[] o2 = {"3","hhh","b"};
Object[] o3 = {"4","lyp","c"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加
userService.batchAdd(batchArgs);

2.批量修改

//批量修改
@Override
public void batchUpdateUser(List<Object[]> batchArgs) {
    String sql = "update t_user set userName=?,status=? where user_id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

3.批量删除

//批量删除
@Override
public void batchDeleteUser(List<Object[]> batchArgs) {
    String sql = "delete from t_user where user_id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

5.事务管理

事务是数据库操作最基本单元,逻辑上一组操作,要么都成功,如果有一个失败所有操作都失败。

例如:银行转账。

事务四个特性(ACID)

  • 原子性(要么成功,要么失败,不可分割)
  • 一致性(数据保持一致)
  • 隔离性(互相不干扰)
  • 持久性

​ 事务一般添加到service层中,在Spring进行声明式事务管理,底层使用AOP原理

​ Spring提供一个接口,代表事务管理类,这个接口针对不同的框架提供不同的实现类

在这里插入图片描述

​ mybatis框架和JdbcTemplate用DataSourceTransactionManager实现类

5.1 转账事务:

在这里插入图片描述

  • 创建数据库及相关表
  • 搭建service层和dao层,完成对象创建和属性注入

service注入dao,在dao注入JdbcTemplate,在JdbcTemplate注入DataSource

  • 在service层加入转账方法,操作dao层数据库加钱和少钱

**问题:**如果业务逻辑层出现有一方错误,会出现一方成功一方失败的现象。

解决方案:事务

  • 开启事务
  • 业务操作
  • 如果没有发生异常提交事务
  • 出现异常的话进行回滚

5.2 注解声明式事务管理

1.配置文件配置事务管理器

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

2.开启事务注解

  • 引入名称空间tx,同上
  • 开启事务注解
<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

3.在service类上或者该方法上添加事务注解@Transactional

  • 如果把注解添加到类上面,表示这个类的所有方法都添加事务
  • 如果把注解放到方法上面,事务只是针对该方法
@Service
@Transactional
public class UserService {

@Transactional注解的参数配置:

  • propagation:事务传播行为

多事务方法直接进行调用,这个过程中事务是如何进行管理的

@Transactional(propagation = Propagation.REQUIRED)

在这里插入图片描述

举例说明:(add方法调用update方法)

​ REQUIRED(默认值):如果add有事务,调用update方法后,使用add方法事务;如果add没有事务,调用update后创建新事务

​ REQUIRED_NEW:无论add是否有事务,都创建新事务

  • isolation:事务隔离级别

事务并发必须设置隔离性以防止:脏读、不可重复读、幻读

(1)脏读:一个未提交事务读取到另一个未提交事务的数据(事件回滚,导致A读取B还未提交的事务,应该读取原始数据)-------不能容许

(2)不可重复读:一个未提交的事务,获取到了一个已经提交修改的事务(A读取B提交的事务,正常来说都提交了才能读取)------可以接受

(3)幻读:一个未提交的数据获取到了另一个事务添加数据

解决方案:设置事务的隔离性

事务情况脏读不可重复读幻读
READ UNCOMMITTED(读未提交)有有有
READ COMMITTED (读已提交)无有有
REPEATABLE READ(可重复读)无无有
SERIALIZABLE(串行化) 效率低无无无

mysql默认:@Transactional(isolation = isolation.REPEATABLE_READ)

  • timeout:超时时间

(1)事务需要在一定时间内进行提交,如果不提交进行回滚
(2)默认值是timeout= -1 ,设置时间以秒单位进行计算

  • readOnly:是否只读

(1)读:查询操作,写:添加修改删除操作
(2)readOnly 默认值 readOnly = false,表示可以查询,可以添加修改删除操作
(3)设置 readOnly 值是 true,设置成 true 之后,只能查询

  • rollbackFor:回滚

​ 设置出现哪些异常进行事务回滚

  • noRollbackFor:不回滚

​ 设置出现哪些异常不进行事务回滚

5.3 xml声明式事务管理

利用Aop将事务功能添加到指定类或方法上

必要准备:

<!-- 组件扫描 -->
<context:component-scan base-package="com.atguigu"></context:component-scan>

<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      destroy-method="close">
    <property name="url" value="jdbc:mysql:///user_db" />
    <property name="username" value="root" />
    <property name="password" value="root" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

<!-- JdbcTemplate对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入dataSource-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

第一步:配置事务管理器

<!--1 创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

第二步:配置通知

<!--2 配置通知-->
<tx:advice id="txadvice">
    <!--配置事务参数-->
    <tx:attributes>
        <!--指定哪种规则的方法上面添加事务-->
        <tx:method name="accountMoney" propagation="REQUIRED"/>
        <!--<tx:method name="account*"/>-->
    </tx:attributes>
</tx:advice>

第三步:配置切入点和切入面

<!--3 配置切入点和切面-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pt" expression="execution(* com.atguigu.spring5.service.UserService.*(..))"/>
    <!--配置切面-->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

5.4 完全注解声明式事务管理

创建配置类:

使用set方法注入连接池属性,和Jdbc对象属性

@Bean:表示方法返回对象,然后对象交给IOC管理

@Configuration //配置类
@ComponentScan(basePackages = "com.transaction") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {

    //创建数据库连接池DruidDataSource
    @Bean
    public DruidDataSource getDruidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///user_db");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        return dataSource;
    }

    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
        //到ioc容器中根据类型找到dataSource做注入
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    //创建事务管理器DataSourceTransactionManager
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

–>
</tx:attributes>
</tx:advice>


第三步:配置切入点和切入面

```xml
<!--3 配置切入点和切面-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pt" expression="execution(* com.atguigu.spring5.service.UserService.*(..))"/>
    <!--配置切面-->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>
手写Spring框架 在学习完Spring框架之后, 我们知道了 Spring容器, IOC, AOP, 事务管理, SpringMVC 这些Spring的核心内容, 也知道了它们底层实现的基本原理, 比如Spring容器就是个Map映射, IOC底层就是反射机制, AOP底层是动态代理, SpringMVC不就是对Servlet进行了下封装嘛! 哈哈, 当然这些只是些皮毛, Spring除此之外还有更加复杂的设计, ... 阅读详情

相关推荐

【Spring框架】Spring概述及基本应用

Spring框架优点,构建及demo

一个真ikun 2062

四、Spring的数据库开发

(4 )在src目录下,创建一个com.itheima.jdbc包,在该包中创建测试类JdbcTemplateTest.在该类的main()方法中通过Spring 容器获取在配置文件中定义的JdbcTemplate实例,然后使用该实例的execute(String sql)方法执行创建数据表的SQL语句。( 1 )在 chapter04项目的com.itheima.jdbc包中,创建Account类,在该类中定义id.username 和 balance属性,以及其对应的getter/setter方法。

m0_62639288的博客 547

【全新官方接口】php检测微信域名拦截,检测微信域名被封

你的域名在微信被拦截的3种常见情况 1、域名因违规或有风险被拦截(红色拦截) 2、类似taobao.com,douyin.com这种的恶意竞争式拦截,淘宝、抖音等微信的竞争对手一般都是白色拦截(白色拦截) 3、有一个中间页的拦截,需要多次点击按钮才可以跳转到你的域名的,多是一些新型域名后缀,例如.top .xyz .link后缀,这种情况,备案后可以解决(备案拦截) 通过php get_headers()函数就可以分析到结果 这个下标为6是一个URL,在微信访问后正是这个讨厌的页面! 如果切换为

TANKING,开源开发者! 2881

Spring 应用如何访问数据库,看这一篇就够了!

在今天的文章中,我们一起盘点了 Spring 开发应用时访问数据库的几种方式,并简单介绍了它们的原理。我把常见的几种方式列举在这篇文章中,作为一个总结,也作为一个参考,以便后续使用。作者:Samson_bu链接:​。

他很懒,但也在努力的生活着 884

HyperLynx实战:手把手教你搞定DDR4信号完整性仿真(附ODT与终端电阻配置避坑)

本文详细介绍了使用HyperLynx进行DDR4信号完整性仿真的实战技巧,重点解析了ODT配置与终端电阻优化的黄金法则。通过模型准备、拓扑构建、ODT扫描等关键步骤,帮助硬件工程师规避常见设计陷阱,提升高速数字电路设计的效率与可靠性。

weixin_30861797的博客 642

80块钱的Wi-Fi SIP话机,搞定北京联通固话无线化改造(附ATCOM A10W详细配置)

本文详细介绍了如何用80元的Wi-Fi SIP话机(以ATCOM A10W为例)实现北京联通固话的无线化改造,摆脱电话线束缚。内容包括设备选购、网络环境配置、SIP账户设置及常见问题排查,特别适合家庭和小型办公室用户。通过SIP协议和IMS系统,轻松实现高质量无线通话。

weixin_33600816的博客 388

Spring的数据库编程

针对数据库操作,Spring框架提供了JdbcTemplate类,JdbcTemplate是一个模板类,Spring JDBC中的更高层次的抽象类均在JdbcTemplate模板类的基础上创建。在dataSource的4个属性中,需要根据数据库类型或者系统配置设置相应的属性值。默认情况下,数据库端口号可以省略,但如果修改过MySQL数据库的端口号,则需要加上修改后的端口号。通过刚才的例子,我们已经了解到JdbcTemplate类中的增,删,改操作,接下来,我们在看看JdbcTemplate类中的查操作。

qq_56444564的博客 1481

kaggle-NeurIPS - Open Polymer Prediction 2025-0.069

本文摘要: 本研究基于多任务学习框架,开发了聚合物物理化学性质预测模型,能够根据SMILES字符串同步预测玻璃化转变温度(Tg)、分数游离体积(FFV)等5种关键性质。针对数据缺失率高、样本不均衡等挑战,采用"先补充后扩充"策略整合多源数据,并融合RDKit分子描述符、ChemBERTa语义特征和自编码器特征构建多维度表征。模型采用硬参数共享架构,结合动态加权损失函数和早停机制,在验证集上表现出色,其中密度预测R²达0.92。研究为聚合物性能的高通量预测提供了有效解决方案,对材料智能设计具有重要参考价值。

2302_78976920的博客 787

什么是spring框架?spring框架到底有什么用?spring框架到底做了些什么?

什么是spring框架,spring框架究竟有什么用呢?我们可以用spring框架来做些什么呢?让我们来具体了解一下,以及经常所说的IOC和AOP是一种怎样的思想,到底是怎么实现这些思想的!

小汤圆的博客 3万+

精度与速度双突破:YOLOv8-Pose 在 RK3588 上实现高性能人体姿态分析部署

本教程从YOLOv8-pose模型的姿态识别训练,到RK3588的边缘量化部署,为你打造了一套“高精度+高实时性+低成本”的人体姿态分析解决方案。无论是健身动作纠正、智能安防行为检测,还是工业人员姿态监控,这套技术都能直接复用——你只需替换数据集与业务逻辑,即可快速落地专属的边缘AI姿态识别系统。如果你在实践中遇到任何卡点,欢迎随时交流。记住,人体姿态识别的价值在于“关键点准、推理快、部署易”,而这三者的平衡,正是你通过本教程能掌握的核心能力。

know_F0727的博客 435

qcc304x笔记之手机端显示电量(九)

默认的sdk有些安卓手机不支持电量显示,所以需要加电量显示的补丁 流程分析 1. 首先新建一个task,并将task注册给电池模块 appBatteryRegister(batteryRegistrationForm) 实现handler处理函数,当battery模块电池电量更新后,会将电池百分比值发送到本模块,然后我们就可以在handler中将实时电量同步到手机端了。 hfpAtCmdInit atCmdTask.task.handler = appAtCmdHandleM...

在云巅的博客 2203

【Spring框架】Spring框架介绍

文章目录Spring框架介绍Spring两大核心技术Spring的优点Spring体系介绍核心容器数据访问/集成Web页面其他模块 Spring框架介绍 Spring框架是分层的 Java SE/EE 应用 full-stack 全栈式轻量级开源框架,以 IOC(Inverse Of Control:控制反转)和 AOP(Aspect Oriented Programming:面向切面编程)为内核,提供了展现层 SpringMVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术

Super_Powerbank的博客 1664

Ollama + OpenCLAW 在 Windows 系统的完整部署指南

Windows 部署优先选 WSL2,避免原生环境的权限/兼容性问题;网络问题通过“离线包+国内镜像”解决,版本问题通过升级 Node.js 解决;内存不足可切换轻量模型或增大 WSL2 内存分配;核心链路:Ollama(模型管理)→ Gateway(网关)→ OpenCLAW TUI(交互),各组件启动正常即可稳定使用。

lpfasd123的博客 2830

spring框架介绍_Spring框架介绍

spring框架介绍 这是Spring框架和Spring核心概念的简介。 在本教程中,我们将介绍Spring Framework的主要优点和功能。 在随后的教程中,我们将学习有关Spring和Spring Boot的更多信息。 总览 我们知道, Spring框架是Java开发人员中最受欢迎的应用程序框架。 Spring以为Java 几乎可以完成的所有工作提供抽象和基础结构框架而闻名。 在较...

最佳 Java 编程 1309

使用 MATLAB/Simulink 搭建一个 无人机群间数据交换与协同控制仿真系统

本文提供了一份详细的Simulink无人机群协同控制仿真教程。主要内容包括:无人机群系统架构设计(去中心化网络、通信分层)、三维运动建模、空-空通信链路实现(距离判断、无线信道)、分布式Consensus控制算法开发,以及性能评估指标设定。教程采用模块化设计思路,通过ModelReference构建多无人机并行模型,并给出了MATLAB函数实现关键算法。最后展示了预期仿真结果(收敛时间<15s、位置偏差<2m)和进阶应用方向(编队飞行、AI协同等),帮助读者掌握群体智能系统的建模与仿真方法。

amy_mhd的博客 159

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

重学Spring框架系列之——什么是Spring框架

说在前面 Spring框架算得上是java程序员必备的一项技能了。不论是早期的SSM或SSH架构,还是现在流行的SpringBoot加SpringCloud构建的分布式、微服务架构。Spring在其中扮演着不可或缺的角色,其重要性也是不言而喻的。 为了更好的工作和自身的提升,菜鸟又重新学习了一下Spring框架,在学习的过程中也有一些收获,从而想着通过文章将自己的学习过程记录下来。也希望可以帮助到有需要的人。如果文章中存在不合理或错误的地方也希望大家可以提出来,我会及时改正,希望我们可以一起进步。 既然我们

first_M的博客 590

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

spring框架_Spring框架介绍

spring框架 这是Spring框架和Spring核心概念的简介。 在本教程中,我们将介绍Spring Framework的主要优点和功能。 在随后的教程中,我们将学习有关Spring和Spring Boot的更多信息。 总览 我们知道, Spring Framework是Java开发人员中最受欢迎的应用程序框架。 Spring以为Java几乎可以完成的所有工作提供抽象和基础结构框架而闻名。 ...

cunhui1209的博客 206

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

如何下载Spring框架

首先进入Spring官网:https://spring.io/ 点击PROJECTS   找到SPRING FRAMEWORK 并点击  因为是托管在github上的,所以点击github标志  找到Spring Framework Artifacts 找到Spring仓库连接  点击Artifacts选项 然后找到菜单下的 libs-release-local...

liutao2001的博客 2万+

框架 - Spring框架

框架 - Spring框架第1章:Spring 概述1.1 概述1.2 优点1.3 Spring 体系结构第2章:IoC 控制反转2.1 概述2.2 Spring 的第一个程序2.3 基于XML的DI2.3.1 set注入2.3.2 构造注入2.3.3 引用类型属性的自动注入2.3.4 为应用指定 多个Spring 配置文件2.4 基于注解的DI2.4.0 使用注解的步骤2.4.1 定义Bean 的注解 @Component2.4.2 简单类型属性注入 @Value2.4.3 byType 自动注入 @Au

佬涛的博客 731
上一篇: 基于JavaWeb的书城管理系统
下一篇: Spring5新功能
Curry_Java
博客等级 码龄5年 20粉丝 16原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值