【Spring（三）】熟练掌握Spring的使用

news2024/11/9 9:58:38

 有关Spring的所有文章都收录于我的专栏：👉Spring👈

目录
一、前言
二、通过静态工厂获取对象
三、通过实例工厂获取对象
四、通过FactoryBean获取对象
五、Bean配置信息重用
六、Bean创建顺序
七、Bean对象的单例和多例
八、Bean的生命周期
九、配置Bean的后置处理器
十、通过属性文件给Bean注入值
十一、基于XML的Bean的自动装配

相关文章

【Spring（一）】如何获取对象（Bean）【Spring（一）】如何获取对象（Bean）
【Spring（二）】java对象属性的配置（Bean的配置）【Spring（二）】java对象属性的配置（Bean的配置）

一、前言

我们这一节来讲解一些Spring的剩下的一些基础内容。

二、通过静态工厂获取对象

我们在将Spring的第一节就讲了在Spring中如何来获取Bean对象，那是一种普通的Bean。而我们这里要讲的是另一种Bean：工厂Bean。它的种类有很多种：静态工厂、实例工厂、通过FactoryBean来获取Bean。

在此之前，同样的我们需要先创建一个静态工厂类。

package com.jl.spring.factory;
import com.jl.spring.bean.Monster;
import java.util.HashMap;
/**
 * @author long
 * @date 2022/9/1
 */
public class MyStaticFactory {
    private static HashMap<String, Monster> monsterMap = null;
    static {
        monsterMap = new HashMap<>();
        monsterMap.put("monster01",new Monster(100,"牛魔王","芭蕉扇"));
        monsterMap.put("monster02",new Monster(200,"白骨精","芭蕉扇"));
    }

    public static Monster getMonster(String key){
        return monsterMap.get(key);
    }
}

<!--配置monster对象，通过静态工厂 -->
<bean id="my_monster01" class="com.jl.spring.factory.MyStaticFactory" factory-method="getMonster">
    <constructor-arg name="key" value="monster02"/>
</bean>
<bean id="my_monster04" class="com.jl.spring.factory.MyStaticFactory" factory-method="getMonster">
    <constructor-arg name="key" value="monster02"/>
</bean>
  1. class：是静态工厂的全路径。
  2. factor-method：表示是静态工厂类的哪个方法返回对象。所以我们的静态工厂类里边必须要提供返回对象的静态方法。
  3. <constructor-arg name="key" value="monster02"/>：而且这里的<constructor-arg>并不是和我们前面章节中一样代表的是类的有参构造，而是我们获取对象方法的参数列表。key是我们的形参名，value是指要返回静态工厂中的哪个对象。

测试类

@Test
public void getBeanByStaticFactor(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    Monster monster = ioc.getBean("my_monster01", Monster.class);
    Monster monster04 = ioc.getBean("my_monster04", Monster.class);
    System.out.println(monster);
    System.out.println(monster04);
    //因为是静态工厂，内存中只加载一份，所以获取到的monster对象是同一个
    System.out.println(monster == monster04); //true
}

结果截图
在这里插入图片描述

三、通过实例工厂获取对象

实例工厂类

package com.jl.spring.factory;

import com.jl.spring.bean.Monster;

import java.util.HashMap;

/**
 * @author long
 * @date 2022/9/1
 */
public class MyInstanceFactory {
    private HashMap<String, Monster> monsterMap;
    {
        monsterMap = new HashMap<>();
        monsterMap.put("monster03",new Monster(300,"牛魔王","芭蕉扇"));
        monsterMap.put("monster04",new Monster(400,"白骨精","芭蕉扇"));
    }

    public Monster getMonster(String key){
        return monsterMap.get(key);
    }
}

<!--通过实例工厂获取Bean-->
<!--配置实例工厂-->
<bean id="myInstanceFactory01" class="com.jl.spring.factory.MyInstanceFactory"/>
<bean id="myInstanceFactory02" class="com.jl.spring.factory.MyInstanceFactory"/>

<bean id="my_monster02" factory-bean="myInstanceFactory01" factory-method="getMonster">
    <constructor-arg name="key" value="monster03"/>
</bean>
<bean id="my_monster03" factory-bean="myInstanceFactory02" factory-method="getMonster">
    <constructor-arg name="key" value="monster03"/>
</bean>

因为是实例工厂，所以前提是先得有一个实例工厂。
1.factory-bean：是实例工厂。
2. factory-method：表示是实例工厂类的哪个方法返回对象。
测试类

@Test
public void getBeanByInstanceFactor(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    Monster monster02 = ioc.getBean("my_monster02", Monster.class);
    Monster monster03 = ioc.getBean("my_monster03", Monster.class);
    System.out.println(monster02);
    System.out.println(monster03);
    //因为实例工厂可以有多个，所以获取到的monster对象不是同一个
    System.out.println(monster02 == monster03); //false
}

结果截图
在这里插入图片描述

四、通过FactoryBean获取对象

创建BeanFactory类，需要实现FactoryBean接口。

package com.jl.spring.factory;

import com.jl.spring.bean.Monster;
import org.springframework.beans.factory.FactoryBean;

import java.util.HashMap;
import java.util.Map;

/**
 * @author long
 * @date 2022/9/1
 */
public class MyFactoryBean implements FactoryBean<Monster> {
    private String key;
    private Map<String,Monster> monster_Map;
    {
        monster_Map = new HashMap<>();
        monster_Map.put("monster01",new Monster(100,"牛魔王","芭蕉扇"));
        monster_Map.put("monster02",new Monster(200,"白骨精","芭蕉扇"));
    }

    public void setKey(String key) {
        this.key = key;
    }

    @Override
    public Monster getObject() throws Exception {
        return monster_Map.get(key);
    }

    @Override
    public Class<?> getObjectType() {
        return Monster.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

<!--通过FactoryBean来获取Bean-->
<bean id="my_monster05" class="com.jl.spring.factory.MyFactoryBean">
    <property name="key" value="monster01"/>
</bean>
  1. class：指定使用的FactoryBean。
  2. key：表示就是FactoryBean 属性key。
  3. value：就是想要获取的对象对应的key。

测试类

@Test
public void getBeanByFactorBean(){
     ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
     Monster monster = ioc.getBean("my_monster05", Monster.class);
     System.out.println(monster);
 }

结果截图
在这里插入图片描述

💡补充说明：
在这里插入图片描述
如果value值不是这个工厂类中的就会报如下的错误：
在这里插入图片描述前两个工厂，value也有同样的要求！！！

五 、Bean配置信息重用

当我们多个Bean对象都需要配置一些相同信息的时候，我们可以使用这个信息重用。这有点类似于对象的继承。

<bean id="monster11" class="com.jl.spring.bean.Monster" abstract="true">
    <property name="monsterId" value="800"/>
    <property name="skill" value="蜇人"/>
    <property name="name" value="蝎子精"/>
</bean>
<bean id="monster12" class="com.jl.spring.bean.Monster" parent="monster11"/>
  1. abstract：当值为true的时候，就代表此Bean就只能用于继承，而不能创建为实例对象。
  2. parent：这个属性代表的是，当前的这个类继承于哪个Bean对象。

测试类

@Test
public void getBeanByExtends(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    Monster monster = ioc.getBean("monster12", Monster.class);
    System.out.println(monster);
}

在这里插入图片描述

六 、Bean创建顺序

我们配置文件中的Student、Department类这里不再列出，这里只是演示Bean的创建顺序。

<!--Bean创建顺序-->
<bean id="student01" class="com.jl.spring.bean.Student" depends-on="department01"/>
<bean id="department01" class="com.jl.spring.bean.Department"/>
  1. 默认Bean的创建顺序是从上到下的。
  2. 如果添加了depends-on="department01"，这时就会先去创建id=department01的这个对象。

💡说明：
 当有ref引用的时候，spring容器都是先将所有对象全部创建完，然后再根据ref来调用对应的Setter()进行注入。这个我们在前边提到过。

测试类

@Test
public void sort(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
}

结果截图
在这里插入图片描述
有结果可以看出，虽然Student在Department的前边，但因为Student依赖于Department，所以Spring容器会先创建Department。

七 、Bean对象的单例和多例

 在Spring中, 默认的是按照单例创建的，即：配置一个bean对象后，Spring容器只会创建一个bean实例。如果我们希望配置的某个bean对象，是以多个实例形式创建的则可以通过配置scope="prototype" 来指定。

我们首先创建一个Cat类。

package com.jl.spring.bean;

import java.util.Calendar;

/**
 * @author long
 * @date 2022/8/30
 */
public class Car {
    private Integer id;
    private String name;
    private Integer price;
    public Car(){}
    public Car(Integer id, String name, Integer price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }
}

<!--配置Cat对象-->
<bean id="cat" class="com.jl.spring.bean.Cat" scope="singleton">
    <property name="name" value="小花猫"/>
    <property name="id" value="1010"/>
</bean>

<bean id="cat02" class="com.jl.spring.bean.Cat" scope="prototype">
    <property name="name" value="小花猫"/>
    <property name="id" value="1010"/>
</bean>
<!--我们这里写了两个配置对象，为了演示他们的区别-->
  1. 默认scope = singleton,只在容器中创建一个实例对象。
  2. 当我们执行getBean的时候，返回的是同一个对象。
  3. 如果我们希望每次获取到的是一个新的对象，可以scope=“prototype”。
  4. 我们Spring容器创建bean对象时候，取决于两个条件：scope="singleton"、lazy_init=false（不开启懒加载）。这两个条件也是默认的。
  5. 当我们希望创建单例对象的时机在getBean的时候，可以lazy_init=true。
  6. scope="prototype"的时候，不管lazy_init=true/false ,在getBean的时候才创建对象，因为是多实例对象，Spring不知道你到底需要多少个。

测试类

@Test
public void getBeanByScope(){
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Cat cat = ioc.getBean("cat", Cat.class);
        Cat cat1 = ioc.getBean("cat", Cat.class);
        System.out.println(cat.hashCode());
        System.out.println(cat1.hashCode());
        System.out.println(cat==cat1);
        Cat cat02 = ioc.getBean("cat02", Cat.class);
        Cat cat03 = ioc.getBean("cat02", Cat.class);
        System.out.println(cat02.hashCode());
        System.out.println(cat03.hashCode());
        System.out.println(cat02==cat03);
    }

结果
在这里插入图片描述

八 、Bean的生命周期

House类

package com.jl.spring.bean;

/**
 * @author long
 * @date 2022/9/2
 */
public class House {
    private String name;
    public House() {
        System.out.println("House构造器被执行...");
    }

    public House(String name) {
        this.name = name;
    }

    public String getName() {
        System.out.println("getName()被执行" + name);
        return name;
    }

    public void setName(String name) {
        System.out.println("setName()被执行" + name);
        this.name = name;
    }

    public void init(){
        System.out.println("init()被执行");
    }
    public void destroy(){
        System.out.println("destroy()被执行");
    }
}

<!--配置House，演示bean的生命周期-->
<bean id="house" class="com.jl.spring.bean.House"
      init-method="init"
      destroy-method="destroy">
    <property name="name" value="豪宅"/>
</bean>
  1. init-method="init"指定bean的初始化方法，在Setter方法之后执行。
  2. init方法执行的时机是由Spring容器来控制的。
  3. destroy-method="destroy"指定bean的销毁方法，在容器关闭的时候执行。
  4. destroy方法执行的时机，由Spring容器来控制。
  5. 容器关闭的方法是close()，close方法是ConfigurableApplicationContext接口中定义的，所以需要注意：右边定义的类型必须是继承了实现了该接口的类才行（左编译，右运行）。
  6. 生命周期执行顺序: 构造器->setter方法->初始化方法->销毁方法。

测试类

@Test
public void testBeanLife(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    House house = ioc.getBean("house", House.class);
    System.out.println("house被创建" + house);
//        左编译，右运行
    ((ConfigurableApplicationContext)ioc).close();
}

结果：
在这里插入图片描述
初始化 init 方法和 destory 方法, 是程序员来指定。
销毁方法就是当关闭容器时才会被调用。即：使用close()方法的时候。

九 、配置Bean的后置处理器

 Spring的后置处理器可以在：Bean对象初始化方法调用前和初始化方法调用后被调用。后置处理器他针对的是Spring容器中所有的Bean对象。后置处理器可以做一些：日期处理/权限的校验/安全的验证/等…。

创建处理器类，处理器类必须实现BeanPostProcessor接口。

package com.jl.spring.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * @author long
 * @date 2022/9/3
 */
public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     * 什么时候被调用：在Bean的init方法之前
     * @param bean 传入在ioc容器创建的bean
     * @param beanName ioc中配置的bean的id值
     * @return 可以对传入的bean进行 修改/处理， 返回
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof House){
            ((House)bean).setName("上海豪宅");
        }
        System.out.println("postProcessBeforeInitialization" + beanName);
        return bean;
    }

    /**
     *什么时候被调用：在Bean的init方法之后
     * @param bean 传入在ioc容器创建的bean
     * @param beanName ioc中配置的bean的id值
     * @return 可以对传入的bean进行 修改/处理， 返回
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization" + beanName);
        return bean;
    }
}

<bean id="house" class="com.jl.spring.bean.House"
     init-method="init"
     destroy-method="destroy">
   <property name="name" value="大豪宅"/>
</bean>

<!--配置后置处理器-->
<bean class="com.jl.spring.bean.MyBeanPostProcessor"/>
  1. 当我们在xml文件配置了MyBeanPostProcessor，这时后置处理器，就会作用在该容器创建的对象。
  2. 我们配置了这个后置处理器bean对象，Spring是通过使用（反射+动态代理+IO+容器+注解）执行到这个方法的。

测试类

@Test
public void testBeanPostProcessor(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans02.xml");
    House house = ioc.getBean("house", House.class);
    ((ConfigurableApplicationContext)ioc).close();
    System.out.println(house);
}

结果截图：
在这里插入图片描述
后置处理器和我们后边要学习的AOP有很大的关系，所以说很重要！！！

十 、通过属性文件给Bean注入值

 使用配置文件的方式，使我们的程序配置在不修改原有代码的情况下完成修改，可以说是特别的灵活和方便。而我们的Spring也提供了这种方式的使用。

我们这里依然使用我们前边的Monster类来演示，所以不再列出。

monsterId=1000
name=\u8718\u86db   
skill=hello

<!--指定属性文件-->
<context:property-placeholder location="classpath:my.properties"/>
<!--配置Monster对象-->
<bean id="monster1000" class="com.jl.spring.bean.Monster">
    <property name="monsterId" value="${monsterId}"/>
    <property name="name" value="${name}"/>
    <property name="skill" value="${skill}"/>
</bean>
  1. location表示指定属性文件的位置，而且需要带上classpath。
  2. 属性值是通过${属性名}。
  3. 这里的属性名就是properties文件 k=v 中的k。

测试类

/**
 * 通过属性文件注入属性值
 */
@Test
public void setBeanByFile(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans03.xml");
    Monster monster1000 = ioc.getBean("monster1000", Monster.class);
    System.out.println(monster1000);
}

结果截图：
在这里插入图片描述
对于配置文件中要是有中文，需要将其转换为ASCII编码之后的字符

十一 、基于XML的Bean的自动装配

 前边提到了很多有关Bean的配置，但还是有些繁琐，比如：我的Service层调用Dao层，需要创建对象。在前边说过这种情况，我们可以通过ref外部引用或者内部注入的方式。但我们这里将要介绍的，是将这些步骤进一步简化的方式。

我们首先创建两个类：OrderService、OrderDao。

package com.jl.spring.dao;

/**
 * @author long
 * @date 2022/9/3
 */
public class OrderDao {
    public void save(){
        System.out.println("保存订单....");
    }
}

package com.jl.spring.service;

import com.jl.spring.dao.OrderDao;

/**
 * @author long
 * @date 2022/9/3
 */
public class OrderService {
    private OrderDao orderDao;

    public OrderDao getOrderDao() {
        return orderDao;
    }

    public void setOrderDao(OrderDao orderDao) {
        this.orderDao = orderDao;
    }
}


<!--配置OrderDAO对象-->
<bean class="com.jl.spring.dao.OrderDao" id="orderDao"/>
<!--配置OrderService对象-->
<bean autowire="byName" class="com.jl.spring.service.OrderService" id="orderService"/>
<!--配置OrderAction对象-->
<bean autowire="byName" class="com.jl.spring.web.OrderAction" id="orderAction"/>
  1. autowire="byType"表示，在创建orderService的时候通过类型的方式 给对象属性 自动完成赋值/引用。比如：OrderService对象中有OrderDao类型对象，就会在容器中去找有没有OrderDao类型对象。如果有，就会自动的装配，如果按照byType方式装配，在这个容器中，就不能有两个OrderDAO类型的对象。
  2. autowire=“byName“表示通过名字完成自动装配。举个例子：比如autowire="byName"class=“com.jl.spring.service.OrderService”。
  • 第一步：OderService 属性 private OrderDao orderDao。
  • 第二步：根据这个属性的SetXxx方法来找 Xxx来找对象id。
  • 第三步：public void setOrderDao() 就会找到id=orderDao对象来进行自动装配；
  • 第四步：如果没有就装配失败。

这两种方式和我们将要在后边介绍的用注解自动装配差不多！

测试类

@Test
public  void serBeanByAutowire(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans03.xml");
    OrderAction orderAction = ioc.getBean("orderAction", OrderAction.class);
    System.out.println(orderAction.getOrderService().getOrderDao());
    System.out.println(orderAction.getOrderService());
    System.out.println(orderAction);
}

结果截图：
在这里插入图片描述

如果文章中有描述不准确或者错误的地方，还望指正。您可以留言📫或者私信我。🙏
最后希望大家多多 关注+点赞+收藏^_^，你们的鼓励是我不断前进的动力！！！
感谢感谢~~~🙏🙏🙏

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

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

相关文章

Weblogic SSRF 漏洞（CVE-2014-4210）分析

Weblogic SSRF 漏洞（CVE-2014-4210）分析

Weblogic SSRF 漏洞是一个比较经典的SSRF 漏洞案例&#xff0c;该漏洞存在于 http://127.0.0.1:7001/uddiexplorer/SearchPublicRegistries. jsp 页面中&#xff0c;如图 1-1 所示图 1-1 Weblogic SSRF 漏洞Weblogic SSRF 漏洞可以通过向服务端发送以下请求参数进行触发&#x…
阅读更多...
ARFoundation系列讲解 - 70 HumanBodyTracking3D

ARFoundation系列讲解 - 70 HumanBodyTracking3D

---------------------------------------------- 视频教程来源于网络，侵权必删！ --------------------------------------------- 一、简介 HumanBodyTracking3D（身体跟踪3D）案例，当设备检查到人体时，会返回检测到人体关节点的3D空间位置（需要在iOS 13或更高版本的A12…
阅读更多...
瞪羚优化算法（Matlab代码实现）

瞪羚优化算法（Matlab代码实现）

&#x1f468;‍&#x1f393;个人主页&#xff1a;研学社的博客 &#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜…
阅读更多...
Java集合类——ArrayList（扩容机制）

Java集合类——ArrayList（扩容机制）

线性表 线性表是n个相同类型元素的有限序列&#xff0c;逻辑上连续物理上不一定是连续的&#xff0c;存储结构上分为顺序存储和链式存储&#xff0c;常见的线性表有&#xff1a;顺序表&#xff0c;链表&#xff0c;栈&#xff0c;队列…… ArrayList 数据结构 ArrayList&am…
阅读更多...
赋值运算符重载，取地址及const取地址操作符重载

赋值运算符重载，取地址及const取地址操作符重载

赋值运算符重载1.运算符重载2.赋值运算符重载3.取地址及const取地址操作符重载如果一个类中什么成员都没有&#xff0c;那么该类简称为空类。而空类中其实并不是真的什么都没有&#xff0c;任何类在什么都不写时&#xff0c;编译器会自动生成以下6个默认成员函数。构造函数&…
阅读更多...
同花顺_代码解析_技术指标_V，W

同花顺_代码解析_技术指标_V，W

本文通过对同花顺中现成代码进行解析&#xff0c;用以了解同花顺相关策略设计的思想 目录 V&R VMA VMACD VOSC VPT VR VRFS VRSI VSTD W&R WVAD V&R 波动区间 用来衡量该股的市场波动风险.即95%的概率波动区间. 行号 1 n -> 250 2 x -> 收…
阅读更多...
【考研英语语法】状语从句精讲

【考研英语语法】状语从句精讲

一、状语从句概述 &#xff08;一&#xff09;状语从句的含义 状语从句&#xff0c;指的就是一个句子作状语&#xff0c;表达“描述性的信息”&#xff0c;补充说明另一个句子&#xff08;主句&#xff09;。描述性的信息有很多种&#xff0c;可以描述时间、地点、原因、结果…
阅读更多...
Web大学生网页成品HTML+CSS音乐吧 7页

Web大学生网页成品HTML+CSS音乐吧 7页

⛵ 源码获取 文末联系 ✈ Web前端开发技术 描述 网页设计题材&#xff0c;DIVCSS 布局制作,HTMLCSS网页设计期末课程大作业 | 音乐网页设计 | 仿网易云音乐 | 各大音乐官网网页 | 明星音乐演唱会主题 | 爵士乐音乐 | 民族音乐 | 等网站的设计与制作 | HTML期末大学生网页设计作…
阅读更多...
Django开发笔记

Django开发笔记

Django开发笔记Django学习1. Django安装path()函数2. 创建项目2.1 终端命令创建2.2 pycharm创建项目3. App4. 创建页面4.1 再写一个页面4.2 模板---Templates4.3 静态文件4.3.1 创建static目录4.3.2 静态文件的引用5. 模板语法案例&#xff1a;伪联通新闻中心6. 请求和响应案例…
阅读更多...
KT148A语音芯片按键版本一对一触发播放常见的问题集锦FAQ_V4

KT148A语音芯片按键版本一对一触发播放常见的问题集锦FAQ_V4

1.1 有3个IO&#xff0c;都是一样的功能吗&#xff1f;从配置文件的说明来看&#xff0c;功能是键控发声&#xff0c;那么3个IO都只能是键控发声吗&#xff1f;还是可以有选择地某个IO对应播放那段语音&#xff1f;三个按键有什么区别&#xff1f;他们和语音号是如何对应的&…
阅读更多...
[附源码]java毕业设计校园环境保护监督系统

[附源码]java毕业设计校园环境保护监督系统

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
SpringBoot SpringBoot 开发实用篇 5 整合第三方技术 5.7 memcached 下载与安装

SpringBoot SpringBoot 开发实用篇 5 整合第三方技术 5.7 memcached 下载与安装

SpringBoot 【黑马程序员SpringBoot2全套视频教程&#xff0c;springboot零基础到项目实战&#xff08;spring boot2完整版&#xff09;】 SpringBoot 开发实用篇 文章目录SpringBootSpringBoot 开发实用篇5 整合第三方技术5.7 memcached 下载与安装5.7.1 memcached 下载5.7.…
阅读更多...
基于Web的个人网页响应式页面设计与实现 HTML+CSS+JavaScript（web前端网页制作课作业）

基于Web的个人网页响应式页面设计与实现 HTML+CSS+JavaScript（web前端网页制作课作业）

&#x1f389;精彩专栏推荐&#x1f447;&#x1f3fb;&#x1f447;&#x1f3fb;&#x1f447;&#x1f3fb; ✍️ 作者简介: 一个热爱把逻辑思维转变为代码的技术博主 &#x1f482; 作者主页: 【主页——&#x1f680;获取更多优质源码】 &#x1f393; web前端期末大作业…
阅读更多...
裁员潮血洗硅谷，推特、Meta、亚麻都扛不住了！

裁员潮血洗硅谷，推特、Meta、亚麻都扛不住了！

据纽约时报14日报道&#xff0c;亚马逊计划最早于本周开启大规模裁员&#xff0c;上万名员工将被波及&#xff0c;Alexa、零售和人力部门将是重灾区。 在亚马逊员工人人自危的情况下&#xff0c;新的噩梦才刚刚开始&#xff0c;因为&#xff0c;这不过是硅谷裁员潮的冰山一角……
阅读更多...
36、Java——一个案例学会三层架构对数据表的增删改查

36、Java——一个案例学会三层架构对数据表的增删改查

✅作者简介&#xff1a;热爱国学的Java后端开发者&#xff0c;修心和技术同步精进。 &#x1f34e;个人主页&#xff1a;Java Fans的博客 &#x1f34a;个人信条&#xff1a;不迁怒&#xff0c;不贰过。小知识&#xff0c;大智慧。 &#x1f49e;当前专栏&#xff1a;Java案例分…
阅读更多...
Spring Security（1）

Spring Security（1）

您好&#xff0c;我是湘王&#xff0c;这是我的CSDN博客&#xff0c;欢迎您来&#xff0c;欢迎您再来&#xff5e; 虽然说互联网是一个非常开发、几乎没有边界的信息大海&#xff0c;但说起来有点奇怪的是&#xff0c;每个稍微有点规模的互联网应用都有自己的权限系统&#xff…
阅读更多...
BSV 上的 PLONK

BSV 上的 PLONK

我们很自豪地宣布 BSV 现在支持 PLONK。关于 PLONK 工作原理的详细说明&#xff0c;可以参考我们之前的解释 第一部分 和 第二部分。 我们之前已经实现了 Groth16&#xff0c;这是最小且最高效的 SNARK 构造。但是&#xff0c;它需要为每个电路进行可信设置。通过消除对每条电…
阅读更多...
算法工程师应该熟知的C++高级用法

算法工程师应该熟知的C++高级用法

1. lambda表达式&#xff08;C11&#xff09; 1.1 lambda表达式的组成 []/*1*/ ()/*2*/ mutable/*3*/ throw()/*4*/ -> int/*5*/ {}/*6*/capture子句参数列表(optional)可变规范(optional)异常定义(optional)返回类型(optional)函数体 1.2 即看即用 语法&#xff1a; […
阅读更多...
我现在是如何听歌的？

我现在是如何听歌的？

个人听歌需求 首先讲下个人听歌的情况&#xff0c;再讲讲我是怎么解决自己的听歌需求的&#xff0c;不一定适合所有人&#xff0c;但多少有点启发。我个人听歌的特殊需求其实还蛮多的。 比如&#xff1a; 突然会想单曲循环一首歌&#xff0c;直到耳朵说够了。 喜欢组装各种歌…
阅读更多...
小啊呜产品读书笔记001：《邱岳的产品手记-06》第13讲 无用却必要：产品规划【上】 第14讲 留白与节奏：产品规划【下】

小啊呜产品读书笔记001：《邱岳的产品手记-06》第13讲 无用却必要：产品规划【上】 第14讲 留白与节奏：产品规划【下】

小啊呜产品读书笔记001&#xff1a;《邱岳的产品手记-06》第13讲 无用却必要&#xff1a;产品规划【上】 & 第14讲 留白与节奏&#xff1a;产品规划【下】一、今日阅读计划二、泛读&知识摘录1、第13讲 无用却必要&#xff1a;产品规划【上】2、第14讲 留白与节奏&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023