Spring5框架三：IOC操作 - 基于xml

最新推荐文章于 2024-06-14 14:24:42 发布
最新推荐文章于 2024-06-14 14:24:42 发布
阅读量112 收藏
点赞数
分类专栏： Spring5 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/N_ZSX/article/details/124402338
版权

IOC操作 - 基于xml

导读

  1. 整篇包含两个部分创建对象、注入属性

  2. 注入属性中包括十个部分

    ① set方法注入属性

    ② 带参构造器注入属性

    ③ 特殊类型属性注入

    ④ 引入外部bean、内部bean和级联赋值

    ⑤ 集合属性注入及提取

    ⑥ FactoryBean

    ⑦ bean作用域

    ⑧ bean生命周期

    ⑨ 自动装配

    ⑩ 引入外部属性文件

一、xml内的bean标签属性
  1. id属性：

    唯一标识

  2. class属性：

    类的全路径，即包和类的路径

  3. scope属性

    signleton，单实例对象，默认值

    prototype，多实例对象

    request，一次请求有效，并将该值放在request作用域内

    session，一次会话有效，并将该值放在session作用域内

二、创建对象
  1. 默认调用的是无参构造器进行对象的创建
    <bean id="book" class="com.atguigu.spring5.Book"></bean>
三、注入属性
  1. DI：依赖注入

    就是注入属性，需要在创建对象的基础之上完成

四、注入属性方式一 - set方法注入属性
  1. 创建类，定义属性和对应的set方法
    public class Book {
    private String bname;
    private String bauthor;

    public Book() {
    }

    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
}
  2. xml配置文件 - set方法注入属性
    <?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="book" class="com.atguigu.spring5.Book">
        <property name="bname" value="On Java"></property>
        <property name="bauthor" value="布鲁斯·埃克尔"></property>
    </bean>
</beans>
    注：如果没有写set方法，property标签内会报错
  3. p名称空间注入属性（ set方法注入属性的另一种写法 ）
    ① 添加p名称空间在配置文件中
    xmlns:p="http://www.springframework.org/schema/p"
    ② 注入属性
    <bean id="book" class="com.atguigu.spring5.Book" p:bname="图灵传" p:bauthor="jein">
    ③ 完整写法
    <?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="book" class="com.atguigu.spring5.Book" p:bname="图灵传" p:bauthor="jein"></bean>
</beans
五、注入属性方式二 - 有参构造器注入属性
  1. 创建类，定义属性和带有参数的构造器
    public class Orders {
    private String oname;
    private String address;

    public Orders() {
    }

    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }

    public void testOrder() {
        System.out.println(oname+"::"+address);
    }
}
  2. 配置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="order" class="com.atguigu.spring5.Orders">
        <constructor-arg name="oname" value="电脑"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>
</beans>
  3. index：有参构造注入的另一种写法
    <!-- 也可通过index，表示有参构造器内的第几个参数，但一般不使用 -->
<bean id="order" class="com.atguigu.spring5.Orders">
    <constructor-arg index="0" value="电脑"></constructor-arg>
    <constructor-arg index="1" value="China"></constructor-arg>
</bean>
  4. 测试方法
    public class TestSpring { 
    @Test
    public void testOrder() {
        // 1.解析指定的xml文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        // 2.创建对象
        Orders order = context.getBean("order", Orders.class);
        order.testOrder();
    }
}
六、注入其它类型的属性
  1. 字面量

    就是指固定值，包括基本数据类型、对象等

  2. 字面量为null值
    <property name="bname"><null/></property>

    输出后bname的值就是null

  3. 字面量中包含特殊符号
    <!-- 第一种方式：将特殊字符用转义字符代替，比如'&gt;'代表'>'  '&lt;' 代表'<' -->
<!-- 第二种方式-->
<property name="bname" ><value><![CDATA[<<南京>>]]></value></property>
七、注入属性 - 引入外部bean
  1. 概念

    在service层调用dao层内的类中的方法，就叫做引入外部bean

  2. 创建service层和dao层
    // dao层
public interface UserDAO {
    public void add();
}

public class UserDAOImpl implements UserDAO{
    @Override
    public void add() {
        System.out.println("dao层 - add方法......");
    }
}

// service层
public interface UserService {
    public void update();
}

public class UserServiceImpl implements UserService{
    // 创建UserDAO属性
    private UserDAO userDAO;
    // 创建UserDAO属性的set方法
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    @Override
    public void update() {
        System.out.println("service层 - update方法...........");
        userDAO.add();
    }
}
  3. spring配置文件
    <?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">
    
    <!-- service的对象创建 -->    
    <bean id="userService" class="com.atguigu.spring5.service.UserServiceImpl">
        <!-- 注入UserDAO属性 
			name：类内的属性名称
			ref：dao对象创建bean标签内的id值
		-->
        <property name="userDAO" ref="userDAO"/>
    </bean>
    <!-- dao对象创建 --> 
    <bean id="userDAO" class="com.atguigu.spring5.dao.UserDAOImpl"></bean>
</beans>
八、注入属性 - 内部bean和级联赋值
  1. 用途

    解决数据库表与表之间的一对一、一对多、多对多关系的属性注入

  2. 一对多

    一个部门有多个员工

    // 部门类
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 setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
}
  3. 内部bean

    一个bean内嵌套另一个bean

    <?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="emp" class="com.atguigu.spring5.bean.Emp">
        <!-- 注入两个基本属性 -->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!-- 注入对象类型属性 -->
        <property name="dept">
            <!-- 内部bean -->
            <bean id="dname" class="com.atguigu.spring5.bean.Dept">
                <property name="dname" value="安保部"></property>
            </bean>
        </property>
    </bean>
</beans>
  4. 级联赋值
    <?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="emp" class="com.atguigu.spring5.bean.Emp">
        <!-- 注入两个基本属性 -->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!-- 级联赋值：ref为引用类型属性所在类的对象创建bean中的id值 -->
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.atguigu.spring5.bean.Dept">
        <property name="dname" value="安保部"></property>
    </bean>
</beans>
  5. 级联赋值的另一种写法

    这种写法，要做Emp类中创建get方法

    <bean id="emp" class="com.atguigu.spring5.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.atguigu.spring5.bean.Dept">
    <property name="dname" value="安保部"></property>
</bean>
九、注入属性 - 集合
  1. 创建类
    public class Stu {
    // 1.数组类型的属性
    private String[] courses;
    // 2.List类型的属性
    private List<String> list;
    // 3.Map类型的属性
    private Map<String,String> map;
    // 4.Set类型的属性
    private Set<String> sets;
	// 5.List类型，值是对象类型的属性
    private List<Course> courseList;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }
}
  2. 在Spring配置文件内注入属性
    <?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="stu" class="com.atguigu.spring5.conllections.Stu">
        <!-- 1.数组类型的属性注入 -->
        <property name="courses">
            <array>
                <value>Java</value>
                <value>Spring</value>
            </array>
        </property>
        <!-- 2.List类型的属性注入 -->
        <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>
        <!-- 3.Map类型的属性注入 -->
        <property name="map">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="LINUX" value="linux"></entry>
            </map>
        </property>
        <!-- 4.Set类型的属性注入 -->
        <property name="sets">
            <set>
                <value>SpringMVC</value>
                <value>MyBatis</value>
            </set>
        </property>
    </bean>
</beans>
  3. 在集合中设置对象类型的属性
    <bean id="stu" class="com.atguigu.spring5.conllections.Stu">    
    <!-- 5.List类型,值是对象类型的属性注入 -->
    <property name="courseList">
        <list>
            <ref bean="course1"></ref>
            <ref bean="course2"></ref>
        </list>
    </property>
</bean>
<!-- 创建多个Course对象 -->
<bean id="course1" class="com.atguigu.spring5.conllections.Course">
    <property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.atguigu.spring5.conllections.Course">
    <property name="cname" value="MyBatis框架"></property>
</bean>
十、注入属性 - 集合注入的共用部分提取及注入
  1. 在Spring配置文件中引入名称空间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">    
</beans>
  2. 提取List集合类型的属性
    <util:list id="bookList">
    <value>On Java</value>
    <value>Think In Java</value>
    <value>Linux and Shell</value>
</util:list>
<bean id="stu" class="com.atguigu.spring5.conllections.Stu">
    <!-- 提取List集合类型属性的注入 -->
    <property name="list" ref="bookList"></property>
</bean>
  3. 提取List集合类型属性的注入
    <bean id="stu" class="com.atguigu.spring5.conllections.Stu">
    <property name="list" ref="bookList"></property>
</bean>
十一、FactoryBbean类型
  1. 普通bean

    在配置文件中，bean中的class是哪个对象类型，返回的也是该对象类型

  2. 工厂bean（FactoryBean）

    在配置文件中，定义bean中的类型和返回值类型可以不一样

  3. 工厂bean的使用
    创建类，让这个类作为工厂bean，实现接口FactoryBean
    public class MyBean implements FactoryBean<Course> {
    // 定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("On Java");
        return course;
    }
    // 返回类型
    @Override
    public Class<?> getObjectType() {
        return null;
    }
    // 是否为单例
    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}
    在Spring配置文件内配置工厂bean
    <bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean"></bean>
    测试返回
    public class TestSpring5 {
    @Test
    public void testStu() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        Course course = context.getBean("myBean", Course.class);
        System.out.println("myBean = " + course);
    }
}

/* 
	注：
	如果写成：  MyBean myBean = context.getBean("myBean", MyBean.class);
	会报错： Bean named 'myBean' is expected to be of type  
	       'com.atguigu.spring5.factorybean.MyBean' 
	       but was actually of type 'com.atguigu.spring5.conllections.Course'
	报错翻译： 名为“myBean”的 Bean 应为“com.atguigu.spring5.factorybean.MyBean”类型，
	         但实际上是“com.atguigu.spring5.conllections.Course”类型
*/
十二、bean作用域
  1. 作用域：scope属性

    就是设置bean创建对象是单实例还是多实例

    signleton，单实例对象，默认值

    prototype，多实例对象

    request，一次请求有效，并将该值放在request作用域内

    session，一次会话有效，并将该值放在session作用域内

  2. 单实例

    在这里插入图片描述

    在这里插入图片描述

  3. 多实例

    在这里插入图片描述

    在这里插入图片描述

  4. signleton与prototype的区别

    signleton：加载Spring配置文件时，就创建了该对象

    prototype：调用getBean方法时，才创建对象

十三、bean生命周期
  1. 生命周期

    对象从创建到销毁的过程

  2. bean生命周期

    ① 通过构造器创建bean实例（无参构造器）

    ② 为bean的属性设置值和对其他bean引用

    ③ 把bean实例传递到bean后置处理器的方法 postProcessBeforeInitialization

    ④ 调用bean的初始化的方法（需要进行配置）

    ⑤ 把bean实例传递到bean后置处理器的方法 postProcessAfterInitialization

    ⑥ bean可以使用了

    ⑦ 当容器关闭的时候，调用bean的销毁方法（需要进行配置）

  3. 新建一个类
    public class Course {
    private String cname;
    public Course() {
        System.out.println("Bean生命周期第一步：执行无参构造器，创建bean实例");
    }
    public void setCname(String cname) {
        this.cname = cname;
        System.out.println("Bean生命周期第二步：调用set方法，注入属性值");
    }
    public void initMethod() {
        System.out.println("Bean生命周期第三步：执行初始化方法");
    }
    public void destroyMethod() {
        System.out.println("Bean生命周期第五步：执行销毁方法");
    }
}
  4. 创建一个后置处理类

    会为所有的bean添加该处理器

    // 实现了BeanPostProcessor接口，故成为了一个后置处理类
public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Bean生命周期第三步：在初始化之前执行");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Bean生命周期第五步：在初始化之后执行");
        return bean;
    }
}
  5. spring配置文件
    <?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">

    <bean id="course" class="com.atguigu.spring5.conllections.Course" init-method="initMethod" destroy-method="destroyMethod">
        <property name="cname" value="On Java"></property>
    </bean>
    <!-- 配置后置处理器，该处理器会为所有的bean都添加上后置处理方法 -->
    <bean id="myBeanPost" class="com.atguigu.spring5.conllections.MyBeanPost"></bean>
</beans>
  6. 测试方法
    public class TestSpring5 {
    @Test
    public void testCourse() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Course course = context.getBean("course", Course.class);
        System.out.println("Bean生命周期第四步 获取创建的bean对象" + course);
        // 手动让bean销毁
        context.close();
    }
}
  7. 执行后的结果

    在这里插入图片描述

十四、xml自动装配
  1. 概念

    根据指定装配规则（属性名称或属性类型），Spring自动将匹配的属性值进行注入

  2. 自动装配属性 autowire

    byName：根据属性名称注入，但是注入值bean得id值和类属性名称要一样才能够自动匹配

    byType：根据属性类型注入，但是匹配类型的bean只能够创建一个对象，否则会报错

  3. 新建两个演示类
    public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

public class Emp {
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "Dept='" + dept + '\'' +
                '}';
    }

    public void add() {
        System.out.println(dept);
    }
}
  4. Spring配置文件
    <?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">

    <!-- 根据属性名称进行自动匹配 -->
	<!-- <bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName"></bean>-->
    <!-- 根据属性l进行自动匹配 -->
    <bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType"></bean>
    
    <bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
</beans>
十五、引入外部属性文件
  1. 导入MySQL数据库和数据库连接池druid的jar包

    在这里插入图片描述

  2. 固定格式配置
    <?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">
    
	<!-- druid连接池固定配置 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql://localhost:8080/bookshop" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
    </bean>
</beans>
  3. 引入外部属性文件配置
    创建 jdbc.properties 配置文件
    prop.driverClassName=com.mysql.cj.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/qqzonedb2?rewriteBatchedStatements=true&serverTimezone=UTC&useUnicode=true\
&characterEncoding=utf-8&useSSL=false
prop.username=root
prop.password=7989775nx
initialSize=5
maxActive=10
maxWait=3000
    spring配置文件
    <?xml version="1.0" encoding="UTF-8"?>
<-- 1.创建context空间名称 -->
<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/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">
	<!-- 2.引入外部属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
	<!-- 3.引用外部属性文件中的标签名 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="url" value="${prop.url}" />
        <property name="username" value="${prop.username}" />
        <property name="password" value="${prop.password}" />
        <property name="driverClassName" value="${prop.driverClassName}" />
    </bean>
</beans>
e_nanxu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
otus-spring-hw-01-ioc-xml:Otus Spring框架开发人员
05-02
Otus Spring框架开发人员学生：Andrei Bogomja 课程：2018年6月作业1.使用XML配置Spring IoC容器学生测验编写程序供学生测试。 在resources文件夹中创建包含5个问题和答案选项的csv文件。 该程序应询问用户名，在...
Spring IoC简单示例-XML配置-Maven构建
03-21
Spring IoC简单示例，使用XML配置依赖注入，使用Maven构建项目 Maven使用及Spring IoC教程参考我的Blog：http://blog.csdn.net/boyazuo
java版商城源码下载-spring-boot-tut:MySpringBootTutorial--Focusingonminimizingt
06-05
话说我当年接触Spring的时候着实兴奋了好一阵，IoC的概念当初第一次听说，感觉有种开天眼的感觉。记得当时的web框架和如今的前端框架的局面差不多啊，都是群雄纷争。但一晃好多年没写过后端，代码这东西最怕手生，...
手写SpringIoc的XML实现方式
01-24
手写SpringIoc的XML实现方式，仿照Spring底层Bean工厂类实现ClassPathXmlApplicationContext
Spring总结——Spring容器、Spring中的IoC
12-22
文章目录Spring总结Spring容器控制反转（IoC）基于XML的IoC Spring总结 Spring容器 什么是Spring容器 从概念上讲：Spring 容器是 Spring框架的核心，是用来管理对象的。容器将创建对象，把它们连接在一起，配置它们...
6、Spring之Bean生命周期~创建Bean（2）
sproutBoy的博客
06-10 682
【代码】6、Spring之Bean生命周期~创建Bean（2）
SpringBoot3 整合 Mybatis 完整版
northcastle的博客
06-14 267
SpringBoot3 整合 MyBatis 的步骤详细记录
springboot与flowable（2）：流程部署
游王子的博客
06-10 288
选择建模器应用程序选择要导出的建模点击导出按钮。将导出的文件复制到项目中。
门面模式Api网关(SpringCloudGateway)
风止的博客
06-05 1748
当前通过Eureka、Nacos解决了服务注册和服务发现问题，使用Spring Cloud LoadBalance解决了负载均衡的需求，同时借助OpenFeign实现了远程调用。然而，现有的微服务接口都直接对外暴露，容易被外部访问。为保障对外服务的安全性，通常在服务端实现的微服务接口会带有一定的权限校验机制。由于应用拆分成多个微服务，每个微服务都需要实现权限校验逻辑，导致当逻辑需要修改时，需要在多个应用中进行修改，增加了开发人员的负担。⽐如企业管理。
SpringBoot内置数据源
2303_79546217的博客
06-11 420
在我们之前学习在配置文件当中配置对应的数据源的时候, 我们设置的数据源其实都是Druid的数据源, 并且其配置有两种方式, 当然这两种方式都需要我们导入对应的有关 德鲁伊 的依赖才行代码如上, 我们已经将对应的数据库的信息都设置完成了, 但是并没有使用哪两种方式, 来设置其数据源具体是什么。
JavaSpringboot+vur前后端分离党员信息管理系统（源码+sql+论文）
u014445459的博客
06-11 770
简化系统开发和维护。它做的事情越多，就封装了常见的JavaScript功能和代码，并提供了一个简单的JavaScript设计相关的模式，用于优化HTML文档操作、事件处理、CSS样式化、动画设计和Ajax请求交互。在互联网技术高速发展的今天，通过互联网的传播会让企业更容易的创造更多的经济效益，利用互联网的传播党建信息管理、通过网页版党建信息管理平台的实现 ，让更多人了解到党建新闻、组织风采等相关信息、得到了更大的宣传，在这样一个大环境下把资源统筹规化起来，就会获得高效的党建党员信息和推广。
SpringCloud之Zuul源码解析
qq_36851469的博客
06-10 240
Zuul 是在云平台上提供动态路由，监控，弹性，安全等边缘服务的框架。Zuul 相当于是设备和 Netflix 流应用的 Web 网站后端所有请求的前门。Zuul 可以适当的对多个 Amazon Auto Scaling Groups 进行路由请求。其架构如下图所示：Zuul提供了一个框架，可以对过滤器进行动态的加载，编译，运行。过滤器之间没有直接的相互通信。他们是通过一个RequestContext的静态类来进行数据传递的。
重生之 SpringBoot3 入门保姆级学习（19、场景整合 CentOS7 Docker 的安装）
最新发布
一名全栈小白的博客
06-14 279
重生之 SpringBoot3 入门保姆级学习（19、场景整合 CentOS7 Docker 的安装）
10 SpringBoot 静态资源访问
zhr2376494700的博客
06-13 828
​ springboot除了可以指定静态资源访问路径的前缀情况下，还可以不使用springboot的默认静态资源目录resources、public、static及MEAT-INFO/resources，可以使用spring.web.resources.static-locations自定义指定类路径下资源访问目录，但是指定后类路径下的默认的静态资源路径则失效。
SpringBoot中实现一个通用Excel导出功能
qq_45525848的博客
06-10 817
SpringBoot中实现一个通用Excel导出功能
SpringBoot+layui实现商品打标
m0_46590717的博客
06-11 431
Springboot+layui实现商品打标
总结之Spring AI（一）——使用Spring AI
IManiy的博客
06-12 887
当前各种AI项目层出不穷，但绝大多数都是用python写的，现在Spring开源了Spring AI项目，让Java开发者也可以轻松给自己的springboot项目集成AI能力。目前spring AI正式版本为0.8.1，支持接入openAI、Ollama、Azure openAI、Huggingface等，可实现聊天、embedding、图片生成、语音转文字、向量数据库、function calling、prompt模板、outputparser、RAG等功能，就像Java版本的langchain。
springboot-自动配置
qq_44895567的博客
06-11 964
根据条件注解（如 @ConditionalOnClass、@ConditionalOnMissingBean 等），决定是否加载对应的配置类或 Bean。：在主类上添加 @SpringBootApplication 注解，该注解包含 @EnableAutoConfiguration，开启自动配置功能。@ConditionalOnProperty：当指定的配置属性存在并符合预期时，才会实例化相应的 Bean。@ConditionalOnClass：当类路径上存在指定的类时，才会实例化相应的 Bean。
springboot与flowable（1）：介绍、Flowable-ui使用
游王子的博客
06-10 646
工作流在企业管理系统中是高频使用的功能，一个最常见的例子是请假加班申请与审批的过程。事实上，工作流引擎能支持的业务场景远远不止单据审批，几乎所有涉及到业务流转、多人按流程完成工作的场景背后都可以通过工作流引擎作为支撑。基于工作流引擎，可以搭建客户关系管理系统（CRM）、运输管理系统（TMS）、仓储管理系统（WMS）、财务费用系统等多种复杂业务系统。
spring ioc的spring.xml
05-23
Spring IOC（Inversion of Control，控制反转）是Spring框架的核心。Spring容器负责管理应用程序中的对象（bean），而不是由程序员手动创建对象。Spring IOC通过读取配置文件或注解来实现对象的创建、注入和管理。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

e_nanxu

感恩每一份鼓励-相逢何必曾相识

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值