第一讲：BeanFactory和ApplicationContext

BeanFactory和ApplicationContext

什么是BeanFactory

  • 它是ApplicationContext的父接口
  • 它才是Spring的核心容器，主要的ApplicationContext实现都组合了它的功能

image-20231205165356277

BeanFactory能做什么?

表面上看BeanFactory的主要方法只有getBean()，实际上控制反转、基本的依赖注入、Bean的生命周期的各种功能，都由他的实现类提供

例如：通过反射查看它的成员变量singletonObjects，singletonObjects内部包含了所有单例bean

实现这个例子前，引出一个类DefaultListableBeanFactory，主要功能是作为一个可配置的、可列表化的 Bean 工厂，用于管理和维护应用程序中的 Bean 定义和实例

DefaultListableBeanFactory继承了DefaultSingletonBeanRegistry类，而DefaultSingletonBeanRegistry类就是专门用来管理单例Bean的

image-20231205165954183

DefaultSingletonBeanRegistry其中有个成员变量也就是singletonObjects

image-20231205170156677

这样我们就找到了单例Bean存储的地方，通过反射调用即可

SpringBoot启动会有很多单例Bean注入，map中包含了所有的单例Bean，我自定义了Component1类注入到其中

@SpringBootApplication
public class Application {public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {//返回容器对象ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);//反射获取singletonObjects属性Field singletonObjects = DefaultSingletonBeanRegistry.class.getDeclaredField("singletonObjects");//开启可操作singletonObjects，否则无法对他进行操作，因为他是private final的singletonObjects.setAccessible(true);//BeanFactory是ConfigurableListableBeanFactory实现类的成员变量ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();//Field.get(Object obj)：获取指定对象obj上此field表示的字段的值Map<String,Object> map = (Map<String, Object>) singletonObjects.get(beanFactory);map.entrySet().stream().filter(e -> e.getKey().startsWith("component")).forEach(e -> {System.out.println(e.getKey() + "=" + e.getValue());});}
}

上面代码最难理解的是singletonObjects.get(beanFactory)，刚开始没有理解到反射，重新翻了反射的代码发现他的作用是填充ConfigurableListableBeanFactory中的singletonObjects属性

Java源码中并没有这个属性，反复查找后发现DefaultListableBeanFactory是ConfigurableListableBeanFactory的实现类，而DefaultListableBeanFactory继承了DefaultSingletonBeanRegistry，所以自然有singletonObjects属性

ApplicationContext能做什么

前面提到过，ApplicationContext是在BeanFactory基础上做了扩展

  • MessageSource：拓展国际化功能
  • ApplicationEventPublisher：事件发布与监听，实现组件之间的解耦
  • ResourcePatternResolver：通过通配符方式获取一组Resource资源
  • EnvironmentCapable：整合 Environment 环境（能通过它获取各种来源的配置信息）

image-20231205165356277

国际化

所谓国际化就是可以通过准备好的配置文件，将语言翻译成各种国家的语言

#准备以下2个配置文件
#messages_en.properties  翻译成英文
hi=hello#messages_zh.properties  翻译成中文  \u4F60\u597D对应着你好
hi=\u4F60\u597D

通过getMessage()转化

@SpringBootApplication
public class Application {public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException {ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);//国际化System.out.println(context.getMessage("hi", null, Locale.US)); //helloSystem.out.println(context.getMessage("hi", null, Locale.CHINA)); //你好}
}

获取Resource资源

@SpringBootApplication
public class Application {public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException {ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);//通配符方式获取一组 Resource 资源Resource[] resources = context.getResources("classpath:application.properties");for (Resource resource : resources) {System.out.println(resource); //class path resource [application.properties]}}
}

整合 Environment 环境

可以读取系统环境变量，也可以读取SpringBoot配置文件

@SpringBootApplication
public class Application {public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException {ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);//整合 Environment 环境System.out.println(context.getEnvironment().getProperty("JAVA_HOME"));System.out.println(context.getEnvironment().getProperty("server.port"));}
}

事件发布与监听

事件发布与监听指的是，一条线程发布特定事件，监听该事件的方法收到消息后，处理该方法，这也是异步的一种思想

创建事件

事件需要继承ApplicationEvent

public class UserRegisteredEvent extends ApplicationEvent {public UserRegisteredEvent(Object source) {super(source);}
}

监听者

@EventListener 可以在 Spring 应用中监听和响应特定类型的事件。当事件发生时，标记有 @EventListener 注解的方法将被自动调用。

@Component
public class Component1 {private static final Logger logger = LoggerFactory.getLogger(Component1.class);@EventListenerpublic void aaa(UserRegisteredEvent event) {logger.info("{}",event);}
}

事件发布

@SpringBootApplication
public class Application {public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException {ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);//发布事件context.publishEvent(new UserRegisteredEvent(context));}
}

BeanFactory实现

代码准备

我们最终想要实现的是，像Spring一样，向自定义的BeanFactory注册Config对象

@Configuration
static class Config{@Beanpublic Bean1 bean1(){return new Bean1();}@Beanpublic Bean2 bean2(){return new Bean2();}
}static class Bean1{private static final Logger logger = LoggerFactory.getLogger(Bean1.class);@Autowiredprivate Bean2 bean2;public Bean1() {logger.info("构造 Bean1()");}public Bean2 getBean2(){return bean2;}
}static class Bean2{private static final Logger logger = LoggerFactory.getLogger(Bean2.class);public Bean2() {logger.info("构造 Bean2()");}
}

具体实现

BeanFactory可以通过registerBeanDefinition注册一个BeanDefinition 对象

public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();//定义一个bean (class，scope，初始化，销毁) scope:单例还是多例AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();beanFactory.registerBeanDefinition("config",beanDefinition);//查看BeanFactory中的beanfor (String name : beanFactory.getBeanDefinitionNames()) {System.out.println(name);}
}

执行以上代码，控制台输出config，证明Config已经注册到BeanFactory中

但是发现Bean1，Bean2并没有注册进去，因为BeanFactory并不会主动调用BeanFactory的后置处理器

现在我们需要为BeanFactory添加一些常用的后置处理器，注意这里仅仅是添加

AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

通过观察控制台输出，发现多了一些BeanFactory中多了些Bean

image-20231207113233914

简单介绍一下目前需要了解几个关键的处理器

  • internalConfigurationAnnotationProcessor：用于处理@Configuration注解，它会解析@Configuration注解并处理其中的@Bean注解，将被注解的方法返回的对象注册为Bean。
  • internalAutowiredAnnotationProcessor：用于处理@Autowired注解，它会解析@Autowired注解并自动装配依赖对象。它会在Bean初始化之前进行处理，确保依赖对象正确注入。
  • internalCommonAnnotationProcessor：用于处理通用注解，如@Resource，@PostConstruct，@PreDestroy等。它会在Bean初始化之前进行处理，执行相应的初始化和销毁方法。

接下来需要让BeanFactory处理器生效，其中internalConfigurationAnnotationProcessor属于BeanFactory后置处理器，internalAutowiredAnnotationProcessor，internalCommonAnnotationProcessor属于Bean的后置处理器，生效方式不一样

//BeanFactory后置处理器的主要功能，补充了一些bean的定义
beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().forEach(beanFactoryPostProcessor -> {beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
});//bean后置处理器，针对bean的生命周期的各个阶段提供扩展，例如@Autowird,@Resource
beanFactory.getBeansOfType(BeanPostProcessor.class).values().forEach(beanPostProcessor -> {beanFactory.addBeanPostProcessor(beanPostProcessor);
});

观察控制台，发现Bean1，Bean2也被出册到了BeanFactory中，并且可以实例化

image-20231207115043414

目前到这看似我们的目标已经完成了，实际上会发现Bean的构造方法是在用到的时候调用的，属于懒汉式，对于单例Bean来说，希望他在注册的时候就已经实例化

//在容器初始化完成后，提前实例化所有的单例Bean
beanFactory.preInstantiateSingletons();

观察控制台发现，构造方法在容器初始化的时候就已经执行了

image-20231207132430162

总结

  • BeanFactory不会主动调用BeanFactory后置处理器
  • BeanFactory不会主动调用Bean后置处理器
  • BeanFactory不会主动初始化单例

补充说明

Bean的后置处理器会有排序的逻辑

举个例子，当一个接口有两个实现类时，这个接口通过依赖注入的形式注入，同时标注了@Autowired以及@Resource，哪个注解会生效，取决于Bean的哪个后置处理器先添加到BeanFactory中

ApplicationContext实现

这里我们主要了解几个常用的ApplicationContext实现

  • ClassPathXmlApplicationContext
  • FileSystemXmlApplicationContext
  • AnnotationConfigApplicationContext
  • AnnotationConfigServletWebServerApplicationContext

基于XML配置文件注册Bean

目前无论是Spring还是SpringBoot都很少用XML的方式，更推荐使用配置类来注册Bean，所以这里了解即可

前置代码

需要注册的Bean

static class Bean1{
}static class Bean2{private Bean1 bean1;public Bean1 getBean1() {return bean1;}public void setBean1(Bean1 bean1) {this.bean1 = bean1;}
}

读取的XML配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="bean1" class="com.yellowstar.spring.demo1.TestApplicationContext$Bean1"/><bean id="bean2" class="com.yellowstar.spring.demo1.TestApplicationContext$Bean2"><property name="bean1" ref="bean1"/></bean>
</beans>
ClassPathXmlApplicationContext

ClassPathXmlApplicationContext的作用是基于classpath下 xml 格式的配置文件来注册Bean

private static void testClassPathXmlApplicationContext(){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("b01.xml");for (String name : context.getBeanDefinitionNames()) {System.out.println(name);}System.out.println(context.getBean(Bean2.class).getBean1());
}

image-20231207152154004

FileSystemXmlApplicationContext

FileSystemXmlApplicationContext的作用是基于磁盘路径下 xml 格式的配置文件来创建

    private static void testFileSystemXmlApplicationContext(){//可以选择绝对路径，也可以是相对路径FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("src/main/resources/b01.xml");}
实现ClassPathXmlApplicationContext

XmlBeanDefinitionReader用于从XML配置文件中读取和解析Bean的定义信息

   DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();//设置配置文件读取到beanFactoryXmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);xmlBeanDefinitionReader.loadBeanDefinitions(new ClassPathResource("b01.xml"));

基于Java配置类注册Bean

AnnotationConfigApplicationContext

AnnotationConfigApplicationContext的作用是基于Java配置类来注册Bean

配置类

@Configuration
static class Config{@Beanpublic Bean1 bean1(){return new Bean1();}@Beanpublic Bean2 bean2(Bean1 bean1){Bean2 bean2 = new Bean2();bean2.setBean1(bean1);return bean2;}
}

实现

private static void testAnnotationConfigApplicationContext(){AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);for (String name : context.getBeanDefinitionNames()) {System.out.println(name);}System.out.println(">==" + context.getBean(Bean2.class).getBean1());
}

这里可以注意到常用的一些后置处理器是自动帮我们加载到容器中了，而基于XML模式的方式还需要在XML另外定义才行

image-20231207153311158

AnnotationConfigServletWebServerApplicationContext

AnnotationConfigServletWebServerApplicationContext也是是基于Java配置类来注册Bean，区别不同的在于他适用于web环境

这块内容比较复杂，先贴代码在详细解释

    private static void testAnnotationConfigServletWebServerApplicationContext(){AnnotationConfigServletWebServerApplicationContext context =new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);}@Configurationstatic class WebConfig{@Beanpublic ServletWebServerFactory servletWebServerFactory(){return new TomcatServletWebServerFactory();}@Beanpublic DispatcherServlet dispatcherServlet(){return new DispatcherServlet();}@Beanpublic DispatcherServletRegistrationBean registrationBean(DispatcherServlet dispatcherServlet){// "/" 代表匹配所有请求return new DispatcherServletRegistrationBean(dispatcherServlet,"/");}@Bean("/")public Controller controller1(){return (request,response) -> {response.getWriter().print("hello");return null;};}}

上述代码的功能就像是启动了Spring服务一样，可以通过访问localhost:8080来进入controller1

image-20231207160024704

其中最重要的是WebConfig必须拥有三大组件

  • ServletWebServer：用于支持 Servlet 容器的接口。它定义了与 Servlet 容器相关的通用操作和属性，允许 Spring 应用程序与不同的 Servlet 容器（如Tomcat、Jetty等）进行交互。
  • DispatcherServlet：用于处理web请求的关键组件之一，所有请求都会经过他
  • DispatcherServletRegistrationBean：用于注册和配置 DispatcherServlet 的 Bean。它允许开发者以编程方式配置 DispatcherServlet 的各种属性，以及将其与特定的 URL 映射关联起来。

Bean的生命周期

通常情况下，Bean的生命周期分为四个阶段

  1. 构造方法阶段：在这个阶段，Spring容器实例化Bean对象，调用其构造方法来创建Bean的实例
  2. 依赖注入阶段：在Bean对象被实例化完成后，Spring容器会对Bean的属性进行依赖注入，将依赖的其他 Bean或值注入到当前 Bean中。
  3. 初始化阶段：在依赖注入完成后，Spring容器会调用Bean的初始化方法，例如使用@PostConstruct注解
  4. 销毁阶段：当容器关闭或销毁时，Spring容器会调用Bean的销毁方法，例如使用@PreDestory注解

这样讲讲方法太枯燥了，我一开始也记不住，通过下面例子可以加深印象

@SpringBootApplication
public class A03Application {public static void main(String[] args) {ConfigurableApplicationContext context = SpringApplication.run(A03Application.class, args);context.close();}
}@Component
public class LifeCycleBean {private static final Logger logger = LoggerFactory.getLogger(LifeCycleBean.class);public LifeCycleBean() {logger.debug("构造");}@Autowiredpublic void autowire(@Value("${JAVA_HOME}") String home){logger.debug("依赖注入:{}",home);}@PostConstructpublic void init(){logger.debug("初始化");}@PreDestroypublic void destory(){logger.debug("销毁");}
}

执行代码可以观察到顺序依次为构造->依赖注入->初始化->销毁

image-20231208113234518

Bean扩展

Spring的扩展程度是非常高的，可以在Bean的各个生命周期中实现自己想要的结果

@Component
public class MyBeanPostProcessor implements DestructionAwareBeanPostProcessor, InstantiationAwareBeanPostProcessor {private static final Logger log = LoggerFactory.getLogger(MyBeanPostProcessor.class);@Overridepublic Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 实例化之前执行, 这里返回的对象会替换掉原本的 bean");}return null;}@Overridepublic boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 实例化之后执行, 这里如果返回 false 会跳过依赖注入阶段");}return true;}@Overridepublic PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 依赖注入阶段执行, 如 @Autowired、@Value、@Resource");}return pvs;}@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 初始化之前执行, 这里返回的对象会替换掉原本的 bean, 如 @PostConstruct、@ConfigurationProperties");}return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 初始化之后执行, 这里返回的对象会替换掉原本的 bean, 如代理增强");}return bean;}@Overridepublic void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 销毁之前执行, 如 @PreDestroy");}}
}

模版方法

模板方法是一种常用的设计模式，在之前对BeanFactory添加后处理器时，比较好奇他这个处理器是如何加载进去的，现在使用模板方法可以试着自己动手实现

先来看一下基础代码，MyBeanFactory是自定义的一个BeanFactory，其中getBean()可以获取Bean

我们的想法是，在getBean()时，添加后处理器，来解析@Autowired或者@Resource

    public static void main(String[] args) {MyBeanFactory beanFactory = new MyBeanFactory();beanFactory.getBean();}static class MyBeanFactory{public Object getBean(){Object bean = new Object();//依赖注入解析return bean;}}

方案一

比较简单的方法就是直接在getBean()中实现，但是这样并不利于扩展，假如需要后续解析其他注解，那么就得修改getBean()方法

方案二

参照之前DefaultListableBeanFactory的做法，我们并没有修改内部方法，而是调用DefaultListableBeanFactory其他方法来添加后处理器

通过一个集合来加载所有后处理器，这样在需要添加后处理器的时候就可以在外部直接调用addBeanPostProcessor()方法，不需要动到MyBeanFactory这个最底层的类

    public static void main(String[] args) {MyBeanFactory beanFactory = new MyBeanFactory();beanFactory.addBeanPostProcessor(() -> System.out.println("解析 @Autowired"));beanFactory.addBeanPostProcessor(() -> System.out.println("解析 @Resource"));beanFactory.getBean();}static class MyBeanFactory{public Object getBean(){Object bean = new Object();//执行后置处理器for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {beanPostProcessor.inject();}return bean;}private static List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor){beanPostProcessorList.add(beanPostProcessor);}}interface BeanPostProcessor{/*** 依赖注入阶段扩展*/void inject();}

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

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

相关文章

产品经理学习-策略产品指标

产品经理学习-策略产品指标

目录&#xff1a; 数据指标概述 通用指标介绍 Web端常用指标 移动端常用指标 如何选择一个合适的数据指标 数据指标概述 指标是衡量目标的一个参数&#xff0c;指一项活动中预期达到的指标、目标等&#xff0c;一般用数据表示&#xff0c;因此又称为数据指标&#xff1b;…
阅读更多...
pytorch03：transforms常见数据增强操作

pytorch03：transforms常见数据增强操作

目录 一、数据增强二、transforms--Crop裁剪2.1 transforms.CenterCrop2.2 transforms.RandomCrop2.3 RandomResizedCrop2.4 FiveCrop和TenCrop 三、transforms—Flip翻转、旋转3.1RandomHorizontalFlip和RandomVerticalFlip3.2 RandomRotation 四、transforms —图像变换4.1 t…
阅读更多...
Github项目推荐-vocal-separate

Github项目推荐-vocal-separate

项目地址 vocal-separate: 项目简述 这是一个音乐和人声分离的项目&#xff0c;基于python开发。有图形化操作界面&#xff0c;看起来还不错。 项目截图
阅读更多...
二叉树BFS

二叉树BFS

前置知识 二叉树节点的定义 二叉树是递归定义的 /*** Definition for a binary tree node.&#xff08;LeetCode&#xff09;*/public class TreeNode {int val;TreeNode left;TreeNode right;TreeNode() {}TreeNode(int val) { this.val val; }TreeNode(int val, TreeNode…
阅读更多...
基本运算器实验静态随机存储器实验

基本运算器实验静态随机存储器实验

1.1 基本运算器实验 1. 实验记录 ①运算结果 首先按照实验指导书进行连线&#xff0c;然后打开试验箱电源&#xff0c;把A&#xff0c;B两个数存到寄存器中&#xff0c;然后改变s3 s2 s1 s0 的值&#xff0c;产生脉冲&#xff0c;观察对应的数据总线上的值以及两个标志位。 …
阅读更多...
微信小程序开发系列-09自定义组件样式特性

微信小程序开发系列-09自定义组件样式特性

微信小程序开发系列目录 《微信小程序开发系列-01创建一个最小的小程序项目》《微信小程序开发系列-02注册小程序》《微信小程序开发系列-03全局配置中的“window”和“tabBar”》《微信小程序开发系列-04获取用户图像和昵称》《微信小程序开发系列-05登录小程序》《微信小程序…
阅读更多...
【Unity入门】热更新框架之xLua

【Unity入门】热更新框架之xLua

目录 一、xLua概述1.1xLua简介1.2xLua安装 二、Lua文件加载2.1执行字符串2.2加载Lua文件2.3自定义loader 三、xLua文件配置3.1打标签3.2静态列表3.3动态列表 四、Lua与C#交互4.1 C#访问Lua4.1.1 获取一个全局基本数据类型4.1.2 访问一个全局的table4.1.3 访问一个全局的functio…
阅读更多...
Maven项目提示Ignored pom.xml问题

Maven项目提示Ignored pom.xml问题

1 环境 &#xff08;1&#xff09;IDEA开发工具&#xff1a;2022.2.1 &#xff08;2&#xff09;JDK&#xff1a;Java17&#xff08;Spring6要求JDK最低版本是Java17&#xff09; &#xff08;3&#xff09;Spring&#xff1a;6.1.2 &#xff08;4&#xff09;Maven 3.8.8 2 …
阅读更多...
pytest --collectonly 收集测试案例

pytest --collectonly 收集测试案例

pytest --collectonly 是一条命令行指令&#xff0c;用于在运行 pytest 测试时仅收集测试项而不执行它们。它会显示出所有可用的测试项列表&#xff0c;包括测试模块、测试类和测试函数&#xff0c;但不会执行任何实际的测试代码。 这个命令对于查看项目中的测试结构和确保所有…
阅读更多...
大模型LLM的微调技术：LoRA

大模型LLM的微调技术：LoRA

0 引言 LoRA(Low-Rank Adaptation)出自2021年的论文“LoRA: Low-Rank Adaptation of Large Language Models” LoRA技术冻结预训练模型的权重&#xff0c;并在每个Transformer块中注入可训练层&#xff08;称为秩分解矩阵&#xff09;&#xff0c;即在模型的Linear层的旁边增…
阅读更多...
Java EE 网络原理之HTTPS

Java EE 网络原理之HTTPS

文章目录 1. HTTPS 是什么&#xff1f;2. "加密" 是什么&#xff1f;3. HTTPS 的工作过程3.1 引入对称加密3.2 引入非对称加密3.3 中间人攻击3.4 引入证书 4. Tomecat4.1 tomcat 的作用 1. HTTPS 是什么&#xff1f; HTTPS也是⼀个应用层协议&#xff0c;是在 HTTP …
阅读更多...
【计算机毕业设计】python+django数码电子论坛系统设计与实现

【计算机毕业设计】python+django数码电子论坛系统设计与实现

本系统主要包括管理员和用户两个角色组成&#xff1b;主要包括&#xff1a;首页、个人中心、用户管理、分类管理、数码板块管理、数码评价管理、数码论坛管理、畅聊板块管理、系统管理等功能的管理系统。 后端&#xff1a;pythondjango 前端&#xff1a;vue.jselementui 框架&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023