4 Spring AOP

news2024/11/22 19:01:54

目录

AOP 简介

传统开发模式

先来看一个需求

解决方案

AOP 图示

Spring 启用 AspectJ 基于 xml 配置

创建 pom.xml

创建 UserService 借口和 UserServiceImpl实现类

创建 LogAdvice 日志通知

创建 log4j.properties

重点：创建 spring-context-xml.xml 配置

创建 AopTest_Xml 测试类

Spring 启用 AspectJ 基于注解配置

改造实现类 UserServiceImpl ，加上 @Service 注解

改造 LogAdvice 日志通知，加上 @Component 和 @Aspect 注解

创建 spring-context-anno.xml 注解配置

创建 AopTest_Anno 测试类

AOP 简介

  1. AOP（Aspect-Oriented Programming, 面向切面编程）: 是一种新的方法论，是对传统 OOP（Object-Oriented Programming，面向对象编程） 的补充。
  2. AOP 的主要编程对象是切面（aspect），而切面是模块化的横切关注点。
  3. 在应用 AOP 编程时， 仍然需要定义公共功能，但可以明确的定义这个功能在哪里， 以什么方式应用, 并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的对象（切面）里。
  4. AOP 的好处：(1) 每个事物逻辑位于一个位置， 代码不分散，便于维护和升级；(2) 业务模块更简洁，只包含核心业务代码。

传统开发模式

先来看一个需求

下面是分别定义了一个接口和它的实现类，功能非常简单，实现正整数的加、减、乘、除操作，代码如下：

CalculateService.java

package com.springdemo.service;

/**
 * Created by qfxl on 2024/05/03.
 */
public interface CalculateService {

    int add(int a, int b);

    int subtract(int a, int b);

    int times(int a, int b);

    int divide(int a, int b);
}

CalculateServiceImpl.java

package com.springdemo.service.impl;

import com.springdemo.service.CalculateService;
import org.springframework.stereotype.Component;

/**
 * Created by qfxl on 2024/05/03.
 */
@Component
public class CalculateServiceImpl implements CalculateService {

    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public int subtract(int a, int b) {
        return a - b;
    }

    @Override
    public int times(int a, int b) {
        return a * b;
    }

    @Override
    public int divide(int a, int b) {
        return a / b;
    }
}

我们的额外需求是：

需求1-做日志：在程序执行期间追踪正在发生的活动
需求2-做验证：希望计算器只能处理正数的运算

如果我们采用传统的方式，只能在每个方法里面先做参数的验证，然后再进行日志记录，这样不仅代码，冗余，而且不利于后期的维护，每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点。

以日志需求为例, 只是为了满足这个单一需求, 就不得不在多个模块（方法）里多次重复相同的日志代码。 如果日志需求发生变化, 必须修改所有模块。

类似于这样：

@Component
public class CalculateServiceImpl implements CalculateService {

    private static final Logger LOGGER = Logger.getLogger(CalculateServiceImpl.class);

    @Override
    public int add(int a, int b) {
    	//先进行参数有效性的验证
    	if(a < 0 || b < 0) {
            System.out.println("参与计算的两个整数有一个为负数: "+a+","+b);
            return -1;
        }
        //做日志
        LOGGER.debug("add操作之前日志...");
        //计算
        int c = a + b;
        LOGGER.debug("add操作之后日志...");
        //返回
        return c;
    }
    //....
}

可以看出，在 add 方法中插入了验证和日志的功能，但是，此方法的核心只是做加法操作，我们在业务实现时还要考虑一些共性的东西，这显然是不好的一种方式，那如何在不改变业务类实现的基础上，动态添加验证、日志功能呢？

解决方案

一种比较好的方式是：使用动态代理解决上述问题
代理设计模式的原理：

使用一个代理将对象包装起来，然后用该代理对象取代原始对象。
任何对原始对象的调用都要通过代理。 代理对象决定是否以及何时将方法调用转到原始对象上。
关于使用程序编写动态代理代码，自己可以去查看相关文档，我们这里不做介绍。
实际上，Spring 中的 AOP 就是基于动态代理技术来实现的，下面我们来详细讲解 AOP 。

AOP 图示

我们把上面的需求以图的方式呈现出来，可以清晰地看到共性的操作，把共性的地方抽取出来，模块化成切面，然后让这个切面按我们的预期进行工作，这就是 AOP 的作用。

1

上面的图示中，我们抽取出来共性，也就是验证和日志功能，但是，光有这个共性，还是不能够模块化成切面的，它还需要其它的辅助元素才能成为一个切面。具体如何使用 AOP 完成上述的需求，Spring 给出了具体的方案，下面让我们来看看详细的案例。

Spring 启用 AspectJ 基于 xml 配置

在演示案例前我们先来了解些 AOP 术语：

  • Aspect 中文意思：切面，它只是一个统称，一种名词，它由 Advice 和 PointCut 组成；
  • Advice 中文意思：通知，它是切面的代码载体，可以想象成一个封装好的 JAVA 类，把共性代码封装在这里；
  • PointCut 中文意思：切点，它是用来匹配目标方法的一段配置信息，可以使用注解也可以使用 XML 来配置，它由多个JoinPoint 组成；
  • JoinPoint 中文意思：连接点，它是指匹配到目标方法之后执行 Advice 的时机，共有如下5种：
    • before： 在目标方法执行之前
    • after：在目标方法之后
    • afterThrowing： 在目标方法的 catch 块中
    • afterReturn： 在目标方法的 finally 块中
    • around： 环绕，相当于是上面4种的一个综合体
  • Weave 中文织入：它是一个过程，就是切面织入到目标对象方法的过程，它的原理是基于 代理 来实现的，Spring 目前支持两种代理：
    • 基于 JDK 自带的动态代理类，java.lang.reflect.Proxy，这是默认的情况，但是这个实现有一个前提条件是目标对象必需要有实现的接口。
    • 基于第三方组件 CGLIB 来生成我们的代理类，它不需要目标对象实现任何接口。

创建 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>spring-aop-demo</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>

        <spring.version>5.1.5.RELEASE</spring.version>
        <lombok.version>1.16.20</lombok.version>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <slf4j.version>1.7.25</slf4j.version>
    </properties>

    <dependencies>

        <!-- Spring Begin -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>
<!--        <dependency>-->
<!--            <groupId>org.springframework</groupId>-->
<!--            <artifactId>spring-aop</artifactId>-->
<!--            <version>${spring.version}</version>-->
<!--        </dependency>-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring End -->

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>

        <!-- lombok Begin -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>
        <!-- lombok End -->

        <!-- Log Begin -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jul-to-slf4j</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <!-- Log End -->

    </dependencies>

    <build>
        <plugins>
            <!-- Compiler 插件, 设定 JDK 版本 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                    <showWarnings>true</showWarnings>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

创建 UserService 借口和 UserServiceImpl实现类

package com.example.spring.aop.demo.xml.service;

public interface UserService {

    public void addUser();

    public boolean updateUser();

    public int deleteUser(int id);
}
package com.example.spring.aop.demo.xml.service.impl;

import com.example.spring.aop.demo.xml.service.UserService;

public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("addUser：添加用户！！！");
    }

    @Override
    public boolean updateUser() {
        System.out.println("updateUser：修改用户！！！");
        return true;
    }

    @Override
    public int deleteUser(int id) {
        System.out.println("deleteUser：删除用户！！！");
        return id;
    }

}

 

创建 LogAdvice 日志通知

package com.example.spring.aop.demo.xml.advice;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Arrays;

public class LogAdvice {

    private static final Logger LOGGER = LoggerFactory.getLogger(LogAdvice.class);

    public void beforeMethod(JoinPoint joinPoint) {
        LOGGER.trace("前置通知...");
        System.out.println("本次要调用的目标对象：" + joinPoint.getTarget());
        System.out.println("本次要调用的目标方法名：" + joinPoint.getSignature().getName());
        System.out.println("本次要调用的目标方法参数：" + Arrays.toString(joinPoint.getArgs()));
    }

    public void afterReturn(Object obj) {
        LOGGER.trace("目标方法返回后, 返回对象结果是：" + obj);
    }

    public void afterMethod() {
        LOGGER.trace("后置通知...");
    }


    public Object aroundMethod(ProceedingJoinPoint pjp){
        Object result = null;

        LOGGER.warn("前置通知！！！");

        try {
            result = pjp.proceed();
        } catch (Throwable e) {
//            e.printStackTrace();

            LOGGER.warn("异常通知！！！");

            throw new RuntimeException(e);
        }

        LOGGER.warn("后置通知！！！");

        return result;
    }
}

创建 log4j.properties

log4j.rootLogger=INFO, console, file

log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.File=logs/log.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.A3.MaxFileSize=1024KB
log4j.appender.A3.MaxBackupIndex=10
log4j.appender.file.layout.ConversionPattern=%d %p [%c] - %m%n


# 便于控制台日志的识别，所以用TRACE日志级别
# 基于 xml 配置的日志打印
log4j.logger.com.example.spring.aop.demo.xml.advice =TRACE

# 基于注解配置的日志打印
log4j.logger.com.example.spring.aop.demo.anno.advice =TRACE

重点：创建 spring-context-xml.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!-- 1.创建目标类 -->
    <bean id="userService" class="com.example.spring.aop.demo.xml.service.impl.UserServiceImpl"></bean>

    <!-- 2.创建切面类（通知对象） -->
    <bean id="logAdvice" class="com.example.spring.aop.demo.xml.advice.LogAdvice"></bean>

    <!-- 3.aop 编程 -->
    <aop:config>
        <!--
        <aop:aspect>：把切面类声明成 "切面"，从而获取到通知（方法）
            ref：切面类引用
         -->
        <aop:aspect id="logAdviceAapect" ref="logAdvice">

            <!--
            <aop:pointcut>：声明一个切入点，所有的通知都可以使用
                id：名称，供所有通知引用；
                expression：切入点表达式
             -->
            <aop:pointcut id="log_pc"
                          expression="execution(* com.example.spring.aop.demo.xml.service.impl.UserServiceImpl.*(..))"/>

            <!--
             <aop:before>：前置通知，在目标方法执行前执行
                method：通知，方法名
                pointcut：切入点表达式，此表达式只能当前通知使用
                pointcut-ref：切入点引用，可以与其他通知共享切入点
             -->
            <aop:before method="beforeMethod" pointcut-ref="log_pc"/>

            <!--
            <aop:after-returning>：返回通知，返回通知在方法返回结果之后执行
                returning：通知方法返回参数的名称
             -->
            <aop:after-returning method="afterReturn" pointcut-ref="log_pc" returning="obj"/>

            <!--
            <aop:after>：后置通知，在目标方法执行后(无论是否发生异常)，执行的通知
             -->
            <aop:after method="afterMethod" pointcut-ref="log_pc"/>

            <!--
            <aop:around>：环绕通知，环绕目标方法执行
                注意：
                    通知方法格式：public Object aroundMethod(ProceedingJoinPoint pjp){...}
                        返回值类型："Object" ，必须要有返回值；返回目标方法执行之后的结果即调用 "pjp.proceed()" 的结果,否则会出现空指针异常
                        参数类型："org.aspectj.lang.ProceedingJoinPoint"，其是 "JoinPoint" 的子类
                        执行目标方法："Object result = pjp.proceed();" ，并抛出异常
             -->
            <aop:around method="aroundMethod" pointcut-ref="log_pc" />
        </aop:aspect>
    </aop:config>

</beans>

创建 AopTest_Xml 测试类

package com.example.spring.aop.demo;

import com.example.spring.aop.demo.xml.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopTest_Xml {

    @Test
    public void xmlTest(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-context-xml.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.addUser();
        System.out.println();

        boolean b = userService.updateUser();
        System.out.println();

        int i = userService.deleteUser(10);
        System.out.println();
    }

}

测试结果：

2

Spring 启用 AspectJ 基于注解配置

改造实现类 UserServiceImpl ，加上 @Service 注解

package com.example.spring.aop.demo.anno.service.impl;

import com.example.spring.aop.demo.xml.service.UserService;
import org.springframework.stereotype.Service;

@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("addUser：添加用户！！！");
    }

    @Override
    public boolean updateUser() {
        System.out.println("updateUser：修改用户！！！");
        return true;
    }

    @Override
    public int deleteUser(int id) {
        System.out.println("deleteUser：删除用户！！！");
        return id;
    }
}

改造 LogAdvice 日志通知，加上 @Component 和 @Aspect 注解

package com.example.spring.aop.demo.anno.advice;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.util.Arrays;


@Component
@Aspect
public class LogAdvice {

    private static final Logger LOGGER = LoggerFactory.getLogger(LogAdvice.class);

    /*
     * 声明一个公共切入点，所有的通知都可以使用
     *      @Pointcut(value = "execution(* com.example.spring.aop.demo.anno.service.impl.UserServiceImpl.*(..))")
     *      等同于 xml 配置里的：
     *      <aop:pointcut id="log_pc" expression="execution(* com.example.spring.aop.demo.anno.service.impl.UserServiceImpl.*(..))"/>
     */
    @Pointcut(value = "execution(* com.example.spring.aop.demo.anno.service.impl.UserServiceImpl.*(..))")
    public void log_pc() {

    }

    @Before("log_pc()")
    public void beforeMethod(JoinPoint joinPoint) {
        LOGGER.trace("前置通知...");
        System.out.println("本次要调用的目标对象：" + joinPoint.getTarget());
        System.out.println("本次要调用的目标方法名：" + joinPoint.getSignature().getName());
        System.out.println("本次要调用的目标方法参数：" + Arrays.toString(joinPoint.getArgs()));
    }

    @AfterReturning(value = "log_pc()", returning = "obj")
    public void afterReturn(Object obj) {
        LOGGER.trace("目标方法返回后, 返回对象结果是：" + obj);
    }

    @After("log_pc()")
    public void afterMethod() {
        LOGGER.trace("后置通知...");
    }


    /*
     * 声明一个切入点表达式，此表达式只能当前通知使用
     *      @Around("execution(* com.example.spring.aop.demo.anno.service.impl.UserServiceImpl.*(..))")
     *      等同于 xml 配置里的：
     *      <aop:around method="aroundMethod" pointcut="execution(* com.example.spring.aop.demo.anno.service.impl.UserServiceImpl.*(..))" />
     */
    @Around("execution(* com.example.spring.aop.demo.anno.service.impl.UserServiceImpl.*(..))")
    public Object aroundMethod(ProceedingJoinPoint pjp) {
        Object result = null;

        LOGGER.warn("前置通知！！！");

        try {
            result = pjp.proceed();
        } catch (Throwable e) {
//            e.printStackTrace();

            LOGGER.warn("异常通知！！！");

            throw new RuntimeException(e);
        }

        LOGGER.warn("后置通知！！！");

        return result;
    }
}

创建 spring-context-anno.xml 注解配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 扫描全部注解 -->
    <context:component-scan base-package="com.example.spring.aop.demo.anno"/>

    <!-- 开启aop动态代理 -->
    <aop:aspectj-autoproxy/>

</beans>

创建 AopTest_Anno 测试类

package com.example.spring.aop.demo;

import com.example.spring.aop.demo.xml.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring-context-anno.xml")
public class AopTest_Anno {

    @Autowired
    private UserService userService;

    @Test
    public void annoTest() {
        userService.addUser();
        System.out.println();

        boolean b = userService.updateUser();
        System.out.println();

        int i = userService.deleteUser(10);
        System.out.println();
    }
}

测试结果：

3

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MyBatis:mybatis基础操作

MyBatis:mybatis基础操作

MyBatis基础操作 新增 接口方法 Insert() insert();删除 接口方法 Delete() delete();Delete("delete from emp where id #{id}") public abstract void delete(Integer id) //如果只传了一个形参,括号内可以随意写修改 接口方法 Update() update();查询 接…
阅读更多...
Jupyter Notebook魔术命令

Jupyter Notebook魔术命令

Jupyter Notebook是一个基于网页的交互式笔记本&#xff0c;支持运行多种编程语言。 Jupyter Notebook 的本质式一个Web应用程序&#xff0c;便于创建和共享文学化程序文档&#xff0c;支持实现代码&#xff0c;数学方程&#xff0c;可视化和markdown。用途包括&#xff1a;数据…
阅读更多...
MATLAB中自定义栅格数据地理坐标R，利用geotifwrite写入tif

MATLAB中自定义栅格数据地理坐标R，利用geotifwrite写入tif

场景描述&#xff1a; 有时候将nc格式的数据转成tiff&#xff0c;或者是将一个矩阵输出成带有地理坐标信息tiff数据时&#xff0c;常常涉及到空间参考的定义和geotiffwrite()函数。 问题描述&#xff1a; 以全球数据为例&#xff0c;今天发现在matlab中对矩阵进行显示后&…
阅读更多...
【大模型学习】大模型相关概念

【大模型学习】大模型相关概念

知识库 Embeding 嵌入&#xff0c;又称向量化、矢量化。 Prompt engineer 提示词工程 提示工程技巧 RAG 检索增强生成&#xff0c;提高文本的准确性和丰富性。 Fine tuning 微调&#xff0c;优化已有人工智能模型以适应特定任务的技术。 AI agent AI代理人&…
阅读更多...
华为机考入门python3--（19）牛客19- 简单错误记录

华为机考入门python3--（19）牛客19- 简单错误记录

分类&#xff1a;字符串 知识点&#xff1a; 分割字符串 my_str.split(\\) 字符串只保留最后16位字符 my_str[-16:] 列表可以作为队列、栈 添加元素到第一个位置 my_list.insert(0, elem) 增加元素到最后一个位置 my_list.append(elem) 删除第一个 my_list.pop(0)…
阅读更多...
Python中的数据可视化：阶梯图matplotlib.pyplot.step()

Python中的数据可视化：阶梯图matplotlib.pyplot.step()

【小白从小学Python、C、Java】 【计算机等考500强证书考研】 【Python-数据分析】 Python中的数据可视化&#xff1a; 阶梯图 matplotlib.pyplot.step() [太阳]选择题 matplotlib.pyplot.step()的功能是&#xff1f; import matplotlib.pyplot as plt import numpy as…
阅读更多...
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。

基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。

演示视频&#xff1a; 基于Springboot的旅游管理系统&#xff08;有报告&#xff09;。Javaee项目&#xff0c;springboot项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构&…
阅读更多...
[1702]java旅游资源网上填报系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

[1702]java旅游资源网上填报系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

一、源码特点 java旅游资源网上填报系统是一套完善的java web信息管理系统&#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采用B/S模式开发。开发环境为 TOMCAT7.0,Myeclipse8.5开发&#xff0c;数据库为Mysql…
阅读更多...
机器视觉系统-条形光源安装位置计算

机器视觉系统-条形光源安装位置计算

使用条形光对反光材质物体打光时&#xff0c;常常出现强烈的光斑反射&#xff0c;影响图像处理。如果不想图像中出现光源的光斑&#xff0c;可以通过计 算得出条形光源的安装范围。 检则PCB板上的二维码字符&#xff0c;使用两个条形光打光的效果图 以及等效模型&#xff1a; …
阅读更多...
CSS 鼠标经过放大元素 不影响其他元素

CSS 鼠标经过放大元素 不影响其他元素

效果 .item:hover{transform: scale(1.1); /* 鼠标悬停时将元素放大 1.1 倍 */ }.item{transition: transform 0.3s ease; /* 添加过渡效果&#xff0c;使过渡更加平滑 */ }
阅读更多...
esp32-cam 2. python opencv 拉取摄像头内容

esp32-cam 2. python opencv 拉取摄像头内容

0. 环境 - win10 python3 - pycharm - esp32-cam http://192.168.4.1 1. 创建工程 File -> Create Project -> -> Location: E:\Workspaces\PycharmProjects\esp32cam_opencv -> Create 2. opencv hello 2.1 添加脚本 File -> New -> Python f…
阅读更多...
39 死锁

39 死锁

目录 1.死锁 2.线程同步 3.条件变量 4.案例 死锁 概念 死锁是指在一组进程中的各个进程均占有不会释放的资源&#xff0c;但因互相申请被其他进程所占用不会释放的资源而处于的一种永久等待状态 四个必要条件 互斥条件&#xff1a;一个资源每次只能被一个执行流使用 请求…
阅读更多...
✔ ★Java大项目——用Java模拟RabbitMQ实现一个消息队列（二）【创建核心类、封装数据库操作】

✔ ★Java大项目——用Java模拟RabbitMQ实现一个消息队列（二）【创建核心类、封装数据库操作】

✔ ★Java大项目——用Java模拟RabbitMQ实现一个消息队列 四. 项⽬创建五. 创建核⼼类 ★创建 Exchange&#xff08;名字、类型、持久化、自动删除、参数&#xff09;创建 MSGQueue&#xff08;名字、持久化、独占标识&#xff09;创建 Binding&#xff08;交换机名字、队列名字…
阅读更多...
如何使用 Node.js 开发一个文件上传功能？

如何使用 Node.js 开发一个文件上传功能？

在 Node.js 中实现文件上传功能可以通过多种方式完成&#xff0c;但其中最常用的方法之一是使用 Express 框架和 Multer 中间件。Express 是一个流行的 Node.js Web 框架&#xff0c;而 Multer 是一个用于处理文件上传的中间件。 步骤 1: 准备工作 首先&#xff0c;确保你已经…
阅读更多...
【系统架构师】-选择题（十一）

【系统架构师】-选择题（十一）

1、紧耦合多机系统一般通过&#xff08;共享内存&#xff09;实现多机间的通信。对称多处理器结构&#xff08;SMP&#xff09;属于&#xff08; 紧耦合&#xff09;系统。 松耦合多机系统又称间接耦合系统,—般是通过通道或通信线路实现计算机间的互连。 2、采用微内核的OS结构…
阅读更多...
（五）SQL系列练习题（上）创建、导入与查询 #CDA学习打卡

（五）SQL系列练习题（上）创建、导入与查询 #CDA学习打卡

目录 一. 创建表 1&#xff09;创建课程表 2&#xff09;创建学生表 3&#xff09;创建教师表 4&#xff09;创建成绩表 二. 导入数据 1&#xff09;导入课程科目数据 2&#xff09;导入课程成绩数据 3&#xff09;导入学生信息数据 4&#xff09;导入教师信息数据 …
阅读更多...
Linux的有关权限的学习

Linux的有关权限的学习

1.认识权限在Linux中的表示 在Linux中&#xff0c;一切皆文件&#xff0c;而每个文件都会有其相对应的操作权限。那么&#xff0c;我们该怎么来认识他们呢&#xff1f; 首先我们可以看到&#xff0c;在每个test文件的前面都会有一个-rw-r--r--这个字符&#xff0c;而这个字符&…
阅读更多...
python实现验证码-图片类型

python实现验证码-图片类型

1 utils.py import randomdef get_random_code():code for i in range(5):# 随机生成大写字母upper_char chr(random.randint(65, 90))lower_char chr(random.randint(97, 122))num_char str(random.randint(0, 9))res random.choice([upper_char, lower_char, num_char]…
阅读更多...
【Unity Shader入门精要 第4章】数学基础（二）

【Unity Shader入门精要 第4章】数学基础（二）

1. Unity中的坐标空间 1.1 五个坐标空间 模型空间 模型自身的3D坐标系空间&#xff0c;左手坐标系是一个相对空间&#xff0c;坐标轴指向随模型旋转变化当物体有父节点时&#xff0c;Transform组件中各属性的值表示的即为该物体在其父物体的模型空间中的值当模型顶点传入顶点…
阅读更多...
js APIS part2

js APIS part2

什么是事件&#xff1f; 事件是在编程时系统内发生的 动作 或者发生的事情。比如用户在网页上 单击 一个按钮 什么是事件监听&#xff1f; 就是让程序检测是否有事件产生&#xff0c;一旦有事件触发&#xff0c;就立即调用一个函数做出响应&#xff0c;也称为 绑定事件或者注册…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023