Spring 使用注解开发、代理模式、AOP

使用注解开发

在Spring4之后，要使用注解开发，必须要保证AOP的包导入了

项目搭建：

  1. 在配置文件中导入约束，增加注解支持

    <?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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd"><context:annotation-config/></beans>

    <?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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd"><!--指定要扫描的包，这个包下的注解就会生效--><context:component-scan base-package="xyz.luck1y.pojo"/><!--注解驱动的包，可以识别spring之外的注解，如前面说的@Resource等等--><context:annotation-config/></beans>

bean

  • 实体类

    @Component 注解

    package xyz.luck1y.pojo;import org.springframework.stereotype.Component;// 等价于xml中的 <bean id="user" class="com.luck1y.pojo.User/>
// @Component 意为组件，说明这个类已经被Spring管理啦，在xml中配置了组件扫描
@Component
public class User {public String name = "刘子";
}

  • 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:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd"><!--指定要扫描的包，这个包下的注解就会生效--><context:component-scan base-package="xyz.luck1y.pojo"/><!--注解驱动的包，可以识别spring之外的注解，如前面说的@Resource等等--><context:annotation-config/></beans>

  • 测试：

    import org.springframework.context.support.ClassPathXmlApplicationContext;
import xyz.luck1y.pojo.User;public class MyTest {public static void main(String[] args) {ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");User user = context.getBean("user", User.class);System.out.println(user.name);}
}

属性如何注入

package xyz.luck1y.pojo;import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;// 等价于xml中的 <bean id="user" class="com.luck1y.pojo.User/>
// @Component 意为组件，说明这个类已经被Spring管理啦，在xml中配置了组件扫描
@Component
public class User {// 相当于<property name="name" value="刘子"/>// 如果是很复杂的配置，还是建议使用xml@Value("刘子")public String name;// 也可以写在set方法上@Value("刘子")public void setName(String name) {this.name = name;}
}

衍生的注解

@Component有几个衍生的注解，我们在web开发中，会按照MVC三层架构分层

  • dao层： @Repository 等价于pojo层的@Component

    package xyz.luck1y.dao;import org.springframework.stereotype.Repository;@Repository
public class UserDao {
}

  • service层：@Service 同样等价于pojo层的@Component

    package xyz.luck1y.service;import org.springframework.stereotype.Service;@Service
public class UserService {
}

  • controller层：（也就是以前的servlet层）@Controller还是等价于pojo层的@Component

    package xyz.luck1y.controller;import org.springframework.stereotype.Controller;@Controller
public class UserController {
}

这样写的话，前面的xml配置文件中componment组件扫描范围要扩大：

<context:component-scan base-package="xyz.luck1y"/>

这四个注解功能是一样的，都是代表将某个类注册到Spring容器中，装配bean

作用域

// 单例
@Scope("singleton")
// 原型
@Scope("prototype")

小结

xml和注解：

  • xml更加万能，适用于任何场合！维护简单方便
  • 注解：不是自己的类用不了，无法引用别的类，维护相对复杂

最佳实践：

  • xml用来管理bean
  • 注解用来完成属性的注入
  • 我们在使用的过程中需要注意必须要让注解生效，即在配置文件中开启注解支持

使用Java的方式配置Spring

完全不使用Spring的xml配置，全交给Java来做

JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能~

使用Java配置类来配置Spring

主配置类

package xyz.luck1y.config;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import xyz.luck1y.pojo.User;// 相当于扫描包
@ComponentScan("xyz.luck1y.pojo")
// 这个也会被Spring容器托管，注册到容器中，因为它本来就是一个Component，它代表这是一个配置类，就是beans.xml
@Configuration
// 相当于xml中引入其他xml
@Import(MyConfig2.class)
public class MyConfig {// 注册一个 bean 就相当于我们之前写的<bean>标签// id 标签 就是这个方法的名字// class 标签 就是这个方法的返回值类型@Beanpublic User getUser(){return new User();}
}

配置类2

package xyz.luck1y.config;import org.springframework.context.annotation.Configuration;@Configuration
public class MyConfig2 {
}

实体类：

package xyz.luck1y.pojo;import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;@Component
public class User {@Value("刘子")public String name;public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +'}';}
}

测试：

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import xyz.luck1y.config.MyConfig;
import xyz.luck1y.pojo.User;public class MyTest {public static void main(String[] args) {// 如果完全使用了配置类的方式去做，我们就只能通过AnnotationConfigApplicationContext 上下文来获取容器，通过配置类.class获取AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);User user = context.getBean("user", User.class);System.out.println(user.getName());}
}

其实SpringBoot底层代码都是用以上注解方式写的，为什么说SpringBoot比Spring更强大呢，就是因为它在底层都固定写好了这些注解，拿过来直接用就好了~

代理模式

多线程那块提到过代理模式，这里再来学习一下代理模式

代理模式是SpringAOP的底层，SpringAOP和SpringMVC是面试重点

代理模式的分类：

  • 静态代理
  • 动态代理

静态代理

角色分析：

  • 抽象角色：一般会使用接口或抽象类来解决
  • 真实角色：被代理的角色
  • 代理角色：代理真实角色，代理真实角色后，会做一系列的附属操作
  • 客户：访问代理对象的人

代理模式的好处：

  • 可以使真实角色的操作更加纯粹，不用去关注其他的公共业务
  • 公共业务交给代理角色，实现了业务的分工（不需要给每一个房东都加相同的功能，这些相同的功能都提取到代理角色）
  • 业务发生扩展的时候，方便集中管理

缺点：

  • 一个真实角色就会产生一个代理角色，真实角色变多时，代码量会翻倍，开发效率会变低
  • 为了解决这个问题，便有了动态代理

测试：

  1. 租房接口

    package xyz.luck1y;// 租房的接口
public interface Rent {public void rent();
}

  2. 房东：真实角色

    package xyz.luck1y;public class Host implements Rent {@Overridepublic void rent() {System.out.println("房东要出租房子");}
}

  3. 中介：代理角色

    package xyz.luck1y;public class Proxy implements Rent {private Host host;public Proxy(){}public Proxy(Host host) {this.host = host;}@Overridepublic void rent() {seeHouse();host.rent();heTong();fee();}// 看房public void seeHouse(){System.out.println("中介带你看房");}// 签合同public void heTong(){System.out.println("签署租赁合同");}// 收中介费public void fee(){System.out.println("收中介费");}
}

  4. 客户我们：

    package xyz.luck1y;public class Client {public static void main(String[] args) {// 房东要租房子Host host = new Host();// 代理，中介来帮房东租房子，但是中介一般有一些其他操作Proxy proxy = new Proxy(host);// 你不用面对房东，直接找中介租房就行proxy.rent();}
}

加深理解

  1. 接口：

    package xyz.luck1y.Demo02;public interface UserService {public void add();public void delete();public void update();public void query();
}

  2. 真实对象：

    package xyz.luck1y.Demo02;
// 真实对象
public class UserServiceImpl implements UserService {@Overridepublic void add() {System.out.println("增加了一个用户");}@Overridepublic void delete() {System.out.println("删除了一个用户");}@Overridepublic void update() {System.out.println("修改了一个用户");}@Overridepublic void query() {System.out.println("查询了一个用户");}
}

  3. 代理对象：

    package xyz.luck1y.Demo02;public class UserServiceProxy implements UserService {private UserServiceImpl userService;public void setUserService(UserServiceImpl userService) {this.userService = userService;}@Overridepublic void add() {log("add");userService.add();}@Overridepublic void delete() {log("delete");userService.delete();}@Overridepublic void update() {log("update");userService.update();}@Overridepublic void query() {log("query");userService.query();}// 日志public void log(String msg){System.out.println("[Debug] 使用了" + msg + "方法");}
}

  4. 客户端：

    package xyz.luck1y.Demo02;public class Client {public static void main(String[] args) {UserServiceImpl userService = new UserServiceImpl();UserServiceProxy userServiceProxy = new UserServiceProxy();userServiceProxy.setUserService(userService);userServiceProxy.add();}
}

为什么不直接在原来的真实对象类加新的内容？

  • 改动原有的业务代码，在工作中是大忌，新增一个类，本来跑的好好的，崩了怎么办~

加一个代理类，可以在原有业务代码不变的基础上进行安全地附加操作

关于AOP

动态代理

  • 动态代理和静态代理的角色一样

  • 动态代理的代理类是动态生成的不是我们直接写好的

  • 动态代理也分为两大类：基于接口的动态代理、基于类的动态代理

    • 基于接口的动态代理【我们在这里使用这种方式】：JDK的动态代理

    • 基于类的动态代理：cglib

    • Java字节码实现：javasist

需要了解两个类：Proxy（代理），InvocationHandler（调用处理程序）

  • InvocationHandler：

    一个接口，java.lang.reflect，反射包下

    InvocationHandler是由代理实例的调用处理程序实现的接口，每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。

    这个接口只有一个方法：Object invoke(Object proxy , 方法 method , Object[] args) throws Throwable

  • Proxy:

    一个类，java.lang.reflect，反射包下

    Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。也就说说可以通过类来调用方法。

代码实现：

自动生成代理类：

package xyz.luck1y.Demo03;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;// 用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {// 被代理的接口private Rent rent;public void setRent(Rent rent){this.rent = rent;}// 生成得到代理类public Object getProxy(){return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);}// 处理代理实例，并返回结果@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 动态代理的本质就是通过反射机制实现log(method.getName());seeHose();Object result = method.invoke(rent, args);getFee();return null;}public void seeHose(){System.out.println("中介带着看房子");}public void getFee(){System.out.println("收取中介费用");}public void log(String msg) {System.out.println("[Log] 执行了" + msg + "方法");}
}

客户端：

package xyz.luck1y.Demo03;import xyz.luck1y.Demo02.UserServiceImpl;public class Client {public static void main(String[] args) {// 真实角色Host host = new Host();// 代理角色不存在ProxyInvocationHandler pih = new ProxyInvocationHandler();// 通过调用程序处理角色来处理我们要调用的接口对象pih.setRent(host);Rent proxy = (Rent) pih.getProxy();proxy.rent();}
}

房东和租房接口：

package xyz.luck1y.Demo03;public class Host implements Rent {@Overridepublic void rent() {System.out.println("房东要出租房子");}
}

package xyz.luck1y.Demo03;// 租房的接口
public interface Rent {public void rent();
}

测试结果：

进一步观察：

package xyz.luck1y.Demo04;import xyz.luck1y.Demo03.Rent;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;// 用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {// 被代理的接口private Object target;public void setTarget(Object target){this.target = target;}// 生成得到代理类public Object getProxy(){return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);}// 处理代理实例，并返回结果@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 动态代理的本质就是通过反射机制实现log(method.getName());seeHose();Object result = method.invoke(target, args);getFee();return null;}public void seeHose(){System.out.println("中介带着看房子");}public void getFee(){System.out.println("收取中介费用");}public void log(String msg) {System.out.println("[Log] 执行了" + msg + "方法");}
}

package xyz.luck1y.Demo04;import xyz.luck1y.Demo02.UserService;
import xyz.luck1y.Demo02.UserServiceImpl;
import xyz.luck1y.Demo03.Host;
import xyz.luck1y.Demo03.Rent;public class Client {public static void main(String[] args) {// 真实角色UserServiceImpl userService = new UserServiceImpl();// 代理角色不存在ProxyInvocationHandler pih = new ProxyInvocationHandler();pih.setTarget(userService);// 动态生成代理类UserService proxy = (UserService) pih.getProxy();proxy.add();}
}

动态代理的优点：

  • 可以使真实角色的操作更加纯粹，不用去关注真实角色的公共业务
  • 公共业务交给代理角色，实现了业务的分工（例子中，不需要给每一个房东都加相同的功能，这些相同的功能都提取到代理角色）
  • 业务发生扩展的时候，方便集中管理
  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务
  • 一个动态代理类可以代理多个类，只要是实现类同一个接口即可。

AOP

什么是AOP

AOP (Aspect Oriented Programming)意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是0OP的延续,是软件开发中一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP在Spring中的作用

提供声明式事务，允许用户自定义切面

  • 横切关注点：跨越应用程序多个模块的方法或功能，即，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志、安全、缓存、事务等等
  • 切面（Aspect）：横切关注点 被模块化的特殊对象，即，它是一个类
  • 通知（Advice）：切面必须要完成的工作，即，它是类中的一个方法
  • 目标（Target）：被通知对象
  • 代理（Proxy）：向目标对象应用通知之后创建的对象
  • 切入点（PointCut）：切面通知执行的“地点”的定义
  • 连接点（JoinPoint）：与切入点匹配的执行点

在SpringAOP中：通过Advice定义横切逻辑，Spring支持五种类型的Advice：

即AOP可以在不改变原有代码的情况下，为业务增加新的功能。

使用Spring实现AOP

AOP织入包，需要导入一个依赖包！

<dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.6</version>
</dependency>

方式一：使用Spring的API接口

接口：

package xyz.luck1y.service;public interface UserService {public void add();public void delete();public void update();public void select();
}

实现类：

package xyz.luck1y.service;public class UserServiceImpl implements UserService {@Overridepublic void add() {System.out.println("增加了一个用户");}@Overridepublic void delete() {System.out.println("删除了一个用户");}@Overridepublic void update() {System.out.println("修改了一个用户");}@Overridepublic void select() {System.out.println("查询了一个用户");}
}

AOP增加日志功能：

package xyz.luck1y.log;import org.springframework.aop.MethodBeforeAdvice;import java.lang.reflect.Method;public class Log implements MethodBeforeAdvice {// method：要执行的目标对象的方法// args：参数// target：目标对象@Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");}
}

package xyz.luck1y.log;import org.springframework.aop.AfterReturningAdvice;import java.lang.reflect.Method;public class AfterLog implements AfterReturningAdvice {// returnValue：返回值@Overridepublic void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {System.out.println("执行了" + method.getName() + "方法，返回结果为：" + returnValue);}
}

xml配置文件：

注意在前面写好aop约束

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!--注册bean--><bean id="userService" class="xyz.luck1y.service.UserServiceImpl"/><bean id="log" class="xyz.luck1y.log.Log"/><bean id="afterLog" class="xyz.luck1y.log.AfterLog"/><!--方式一：使用原生的Spring API接口--><!--配置aop:需要导入aop的约束--><aop:config><!--切入点：expression表达式，execution(要执行的位置！ 修饰词 返回值 类名 方法名 参数)  .. 代表有任意的参数--><aop:pointcut id="pointcut" expression="execution(* xyz.luck1y.service.UserServiceImpl.*(..))"/><!--执行环绕增加--><aop:advisor advice-ref="log" pointcut-ref="pointcut"/><aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/></aop:config>
</beans>

测试：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import xyz.luck1y.service.UserService;public class MyTest {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");// 动态代理代理的是接口，此处为 UserService 接口UserService userService = context.getBean("userService", UserService.class);userService.add();}
}

结果：

方式二：自定义类实现实现AOP

自定义切面插入类：

package xyz.luck1y.diy;public class DiyPointCut {public void before(){System.out.println("=============方法执行前=============");}public void after(){System.out.println("=============方法执后=============");}
}

配置文件：

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!--注册bean--><bean id="userService" class="xyz.luck1y.service.UserServiceImpl"/><bean id="log" class="xyz.luck1y.log.Log"/><bean id="afterLog" class="xyz.luck1y.log.AfterLog"/><!--方式二：自定义类--><!--比第一类简单，但是功能没有第一种强大--><bean id="diy" class="xyz.luck1y.diy.DiyPointCut"/><aop:config><!--自定义切面，ref：要引用的类--><aop:aspect ref="diy"><!--切入点--><aop:pointcut id="point" expression="execution(* xyz.luck1y.service.UserServiceImpl.*(..))"/><!--通知--><aop:before method="before" pointcut-ref="point"/><aop:before method="after" pointcut-ref="point"/></aop:aspect></aop:config>
</beans>

测试：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import xyz.luck1y.service.UserService;public class MyTest {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");// 动态代理代理的是接口，此处为 UserService 接口UserService userService = context.getBean("userService", UserService.class);userService.add();}
}

结果：

方式三：使用注解实现AOP

package xyz.luck1y.diy;
// 方式三：使用注解方式实现AOPimport org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;// 标注这个类是一个切面
@Aspect
public class AnnotationPointCut {@Before("execution(* xyz.luck1y.service.UserServiceImpl.*(..))")public void before(){System.out.println("========方法执行前========");}@After("execution(* xyz.luck1y.service.UserServiceImpl.*(..))")public void after(){System.out.println("========方法执行后========");}// 在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点@Around("execution(* xyz.luck1y.service.UserServiceImpl.*(..))")public void around(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("========环绕前========");// 获得签名Signature signature = joinPoint.getSignature();System.out.println("signature:" + signature);// 执行方法Object proceed = joinPoint.proceed();System.out.println("========环绕后========");System.out.println(proceed);}
}

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!--注册bean--><bean id="userService" class="xyz.luck1y.service.UserServiceImpl"/><bean id="log" class="xyz.luck1y.log.Log"/><bean id="afterLog" class="xyz.luck1y.log.AfterLog"/><!--方式三：使用注解--><bean id="annotationPointCut" class="xyz.luck1y.diy.AnnotationPointCut"/><!--开启注解支持   JDK(默认实现)  CGLib--><!--proxy-target-class 设置为 false 为 JDK 实现，true 是 CGLib 实现--><aop:aspectj-autoproxy proxy-target-class="false"/>
</beans>

测试结果：

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

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

相关文章

华为新版ENSP PRO模拟器测评：性能表现与功能扩展一览

华为新版ENSP PRO模拟器测评：性能表现与功能扩展一览

一、引言 在网络领域不断涌现的新技术和复杂的网络拓扑要求&#xff0c;推动了网络设备模拟器的持续发展和创新。华为作为一家领先的通信技术解决方案提供商&#xff0c;不断致力于为网络工程师和技术从业人员提供更优秀的仿真环境。最近&#xff0c;华为推出了ensp pro模拟器的…
阅读更多...
html 计算器界面

html 计算器界面

其他链接&#xff1a; https://www.freecodecamp.org/news/how-to-build-an-html-calculator-app-from-scratch-using-javascript-4454b8714b98/ https://codepen.io/pen/tour/welcome/start 下面展示一些 内联代码片。 <!DOCTYPE html> <html lang"en">…
阅读更多...
计算机网络 运输层 TCP连接建立、释放

计算机网络 运输层 TCP连接建立、释放

三报文而不是两报文
阅读更多...
苹果正在测试新款Mac mini：搭载M3芯片 配备24GB大内存

苹果正在测试新款Mac mini：搭载M3芯片 配备24GB大内存

据悉苹果目前正在测试新的Mac机型&#xff0c;亮点是采用最新的M3芯片。 据报道&#xff0c;首款搭载M3芯片的设备应该是13英寸的MacBook Pro和重新设计的MacBook Air&#xff0c;Mac mini机型并不在名单上。 M3和M2同样拥有最多8个核心&#xff0c;分别为4个性能核和4个能效核…
阅读更多...
MySQL高阶知识点(一)一条SQL【更新】语句是如何执行的

MySQL高阶知识点(一)一条SQL【更新】语句是如何执行的

一条SQL【更新】语句是如何执行的 首先&#xff0c;可以确定的说&#xff0c;【查询】语句的那一套流程&#xff0c;【更新】语句也是同样会走一遍&#xff0c;与查询流程不一样的是&#xff0c; 更新语句涉及到【事务】&#xff0c;就必须保证事务的四大特性&#xff1a;ACID&…
阅读更多...
Java-IO模型分析

Java-IO模型分析

BIO&#xff08;同步阻塞&#xff09; 利用网络连接传输数据为例&#xff1a; 服务端单线程 服务端只有一个主线程处理客户端的连接和读写处理&#xff0c;此时如果有第二个客户端欲连接并发送消息服务端是接收不到的。 因为读写和等待accept连接都是阻塞的。 sever端代码…
阅读更多...
【TypeScript】TS类型守卫（六）

【TypeScript】TS类型守卫（六）

【TypeScript】TS类型守卫&#xff08;六&#xff09; 【TypeScript】TS类型守卫&#xff08;六&#xff09;一、什么是类型守卫二、in操作符三、typeof操作符四、instanceof操作符五、自定义类型谓词函数 一、什么是类型守卫 TypeScript类型守卫&#xff08;Type Guards&…
阅读更多...
微信小程序调用map数据 并在wxml中对数组进行截取的操作

微信小程序调用map数据 并在wxml中对数组进行截取的操作

wxs文件的位置如图 实现数组截取 只保留五张图片 <wxs module"filter" src"./slicefunc.wxs"></wxs> <view class"wrap"><view class"search-box" bindtap"toSearch"><view class"v1"…
阅读更多...
eclipse 导入项目js报错问题

eclipse 导入项目js报错问题

eclipse 导入项目后会出现项目中的js文件报错&#xff08;红叉&#xff09;&#xff0c;如下图所示&#xff0c;有时候报错的文件很多&#xff0c;需要集中处理。 解决办法&#xff1a; 右键项目名称》Properties》MyEclipse》JavaScript》Include Path&#xff0c;在右侧选择“…
阅读更多...
opencv图片灰度二值化

opencv图片灰度二值化

INCLUDEPATH D:\work\opencv_3.4.2_Qt\include LIBS D:\work\opencv_3.4.2_Qt\x86\bin\libopencv_*.dll #include <iostream> #include<opencv2/opencv.hpp> //引入头文件using namespace cv; //命名空间 using namespace std;//opencv这个机器视…
阅读更多...
jupyter切换conda虚拟环境

jupyter切换conda虚拟环境

环境安装 conda install nb_conda 进入你想使用的虚拟环境&#xff1a; conda activate your_env_name 在你想使用的conda虚拟环境中&#xff1a; conda install -y jupyter 在虚拟环境中安装jupyter&#xff1a; conda install -y jupyter 重启jupyter 此时我们已经把该安装…
阅读更多...
【LeetCode每日一题】——575.分糖果

【LeetCode每日一题】——575.分糖果

文章目录 一【题目类别】二【题目难度】三【题目编号】四【题目描述】五【题目示例】六【题目提示】七【解题思路】八【时间频度】九【代码实现】十【提交结果】 一【题目类别】 哈希表 二【题目难度】 简单 三【题目编号】 575.分糖果 四【题目描述】 Alice 有 n 枚糖&…
阅读更多...
下载程序到西门子PLC

下载程序到西门子PLC

更多关于西门子S7-200PLC内容请查看&#xff1a;西门子200系列PLC学习课程大纲 下载西门子200PLC程序分以下两步&#xff1a; 一.编译程序 1. 如下图1-1所示&#xff0c;使用PPI电缆将PLC和电脑连接上&#xff0c;注意笔记本使用USB转PPI电缆&#xff0c;连接保证给PLC单独供…
阅读更多...
postman官网下载安装登录测试详细教程

postman官网下载安装登录测试详细教程

目录 一、介绍 二、官网下载 三、安装 四、注册登录postman账号&#xff08;不注册也可以&#xff09; postman注册登录和不注册登录的使用区别 五、关于汉化的说明 六、使用示范 一、介绍 简单来说&#xff1a;是一款前后端都用来测试接口的工具。 展开来说&#xff1a;…
阅读更多...
json-server的入门

json-server的入门

由于前端开发的时候&#xff0c;需要向后端请求数据&#xff0c;有的时候后端还没有准备好&#xff0c;所以需要使用一些简单的静态数据&#xff0c;但是我们更加希望能够模拟请求以及请求回来的过程&#xff0c;这个时候就需要使用json-server Json-Server的介绍 json-server…
阅读更多...
funbox3靶场渗透笔记

funbox3靶场渗透笔记

funbox3靶场渗透笔记 靶机地址 https://download.vulnhub.com/funbox/Funbox3.ova 信息收集 fscan找主机ip192.168.177.199 .\fscan64.exe -h 192.168.177.0/24___ _/ _ \ ___ ___ _ __ __ _ ___| | __/ /_\/____/ __|/ __| __/ _ |/ …
阅读更多...
MySQL修改编码

MySQL修改编码

插入中文乱码,我电脑上没有出现&#xff0c;我只是来记录一下 MySQL版本: 8.0.34Windows 查看编码 mysql中输入下面的命令 show variables like ‘character_%’; 乱码的一般是图片中划红线的部分不是utf8 character_set_database是设置数据库的默认编码的 character_set_ser…
阅读更多...
SQL-每日一题【1484. 按日期分组销售产品】

SQL-每日一题【1484. 按日期分组销售产品】

题目 表 Activities&#xff1a; 编写解决方案找出每个日期、销售的不同产品的数量及其名称。 每个日期的销售产品名称应按词典序排列。 返回按 sell_date 排序的结果表。 结果表结果格式如下例所示。 示例 1: 解题思路 前置知识 group_concat函数的功能 　　将group by产生的…
阅读更多...
模拟实现消息队列(以 RabbitMQ 为蓝本)

模拟实现消息队列(以 RabbitMQ 为蓝本)

目录 1. 需求分析1.1 介绍一些核心概念核心概念1核心概念2 1.2 消息队列服务器&#xff08;Broker Server&#xff09;要提供的核心 API1.3 交换机类型1.3.1 类型介绍1.3.2 转发规则&#xff1a; 1.4 持久化1.5 关于网络通信1.5.1 客户端与服务器提供的对应方法1.5.2 客户端额外…
阅读更多...
uni-app弹窗列表滚动, 弹框下面的内容也跟随滚动解决方案

uni-app弹窗列表滚动, 弹框下面的内容也跟随滚动解决方案

滑动弹窗里的列表&#xff0c;弹框下面的内容也会跟着滑动&#xff0c;导致弹窗中的列表不能正常滚动 1.弹窗组件代码&#xff0c;需要在最外层的view中加入touchmove.stop.prevent"moveHandle"&#xff0c;且弹窗中需要滚动的列表要使用scroll-view标签包裹起来&…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023