零基础学JavaWeb开发（十九）之 spring框架（2）

最新推荐文章于 2024-09-23 17:27:13 发布
最新推荐文章于 2024-09-23 17:27:13 发布
阅读量1.2k 收藏
点赞数
分类专栏： JavaWeb Java 文章标签： spring java 后端 bean web
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54828627/article/details/128747772
版权
Java 同时被 2 个专栏收录
100 篇文章 6 订阅
订阅专栏
JavaWeb
29 篇文章 2 订阅
订阅专栏

3.3、SpringBean的注入方式

3.3.1、创建对象和set方法注入属性

1. 什么是Bean管理

使用spring创建对象

使用spring注入属性

2. Bean的管理有两种方式

1. 基于XML方式配置

基于XML方式创建对象

<bean id="userEntity" class="com.mayikt.entity.UserEntity"></bean>

在spring的配置文件中，会配置一个bean标签，注入bean的信息 创建bean对象

Id：获取bean对象 唯一bean对象的名称； bean的名称不允许重复

Class属性： 类的完整路径地址（类名称+包名称）

默认底层使用反射技术执行无参数构造函数

2. 基于xml方式注入属性

DI 依赖注入： 对象的属性注入值； （spring实现）

1. 第一种实现方式：基于对象属性set方法实现

<bean id="bookEntity" class="com.mayikt.entity.BookEntity">
    <property name="bookName" value="蚂蚁课堂面试宝典"></property>
    <property name="bookPrice" value="108.00"></property>
</bean>
在Bean标签下 在定义一个属性<property>标签
Name：类中的属性名称 
Value：需要注入属性值

3.3.2、有参构造函数注入属性

实例类

public class OrderEntity {
    private String orderId;
    private String orderName;

    public OrderEntity(String orderId, String orderName) {
        this.orderId = orderId;
        this.orderName = orderName;
    }

    @Override
    public String toString() {
        return "OrderEntity{" +
                "orderId='" + orderId + '\'' +
                ", orderName='" + orderName + '\'' +
                '}';
    }
}

Xml配置文件

<bean id="orderEntity" class="com.mayikt.entity.OrderEntity">
 <!--
        <constructor-arg name="orderId" value="123456"></constructor-arg>
    <constructor-arg name="orderName" value="来龙虎山学习啦"></constructor-arg>
  -->
    <constructor-arg index="0" value="123456"></constructor-arg>
    <constructor-arg index="1" value="来龙虎山学习啦"></constructor-arg>
</bean>

<constructor-arg name 指定参数列表名称

<constructor-arg index 指定参数列表索引

3.3.3、p名称空间注入

1. Xml头部引入P标签

<?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>

2. 使用p标签注入属性：

<bean id="bookEntity" class="com.mayikt.entity.BookEntity" p:bookName="mayikt" p:bookPrice="66">
</bean>

使用p标签为属性注入值：调用set方法注入值

3.3.4、注入空值和特殊符号

注入空值属性

<bean id="bookEntity2" class="com.mayikt.entity.BookEntity">
    <property name="bookName" value="mayikt">
    </property>
    <property name="bookPrice" >
        <null></null>
    </property>

注入特殊符号

转移注入方式

<< 转移为：<<

>>转移为：>>

<bean id="bookEntity3" class="com.mayikt.entity.BookEntity">
    <!--    <property name="bookName" value="<<武汉>>"></property> -->
    <property name="bookName" value="<<武汉>>"></property>
    <property name="bookPrice">
        <null></null>
    </property>
</bean>

Cdata注入方式

<![CDATA[<<>>]]>

<bean id="bookEntity4" class="com.mayikt.entity.BookEntity">
    <!--    <property name="bookName" value="<<武汉>>"></property> -->
    <property name="bookName">
        <value><![CDATA[<<武汉>>]]></value>
    </property>
    <property name="bookPrice">
        <null></null>
    </property>
</bean>

3.3.5、注入属性外部bean

Com.mayikt.controller---控制层

Com.mayikt.service----业务逻辑层

MemberService ##new MemberDao().

Com.mayikt.dao----数据库访问层

MemberDao----

Com.mayikt.service

调用：memberService

Com.mayikt.dao

MemberDaoImpl

public interface MemberDao {
    void addMember();
}

public class MemberDaoImpl implements  MemberDao {
   public void addMember() {
       System.out.println("dao member");
    }
}
import com.mayikt.dao.MemberDao;
import com.mayikt.dao.MemberDaoImpl;

public class MemberService {
    private MemberDao memberDao;

    public MemberDao getMemberDao() {
        return memberDao;
    }

    public void setMemberDao(MemberDao memberDao) {
        this.memberDao = memberDao;
    }

    public void addMember() {
        System.out.println("<<<Service Service>>");
        // 原始的方式
//        MemberDao memberDao = new MemberDaoImpl();
//        memberDao.addMember();
        memberDao.addMember();
    }
}
<?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">


    <!--
     注入useService
     -->
    <bean id="memberService" class="com.mayikt.service.MemberService">
        <!--  注入userDao
         name 属性值: 类中属性的名称；
         ref 创建MemberDaoImpl类的 bean的id
         -->
        <property name="memberDao" ref="memberDao"></property>
    </bean>
    <bean id="memberDao" class="com.mayikt.dao.MemberDaoImpl"></bean>
</beans>

3.3.6、注入内部bean

1. 数据库表一对多或者一对一的关系

2. 部门--n多个员工 一对多

3. 站在员工角度考虑员工属于那个部门

4. 站在部门的角度考虑部门下n多个员工

1. 在数据库中表中有一对一一对多的关系；

2. 一对多关系；部门与员工 一个部门会有多个员工 一个员工属于一个部门；

3. 实体类之间表示一对多的关系；

实体类员工对象

public class EmpEntity {

    private String name;
    private Integer age;
    /**
     * 员工属于那个部门
     */
    private  DeptEntity deptEntity;
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setDeptEntity(DeptEntity deptEntity) {
        this.deptEntity = deptEntity;
    }

    @Override
    public String toString() {
        return "EmpEntity{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", deptEntity=" + deptEntity +
                '}';
    }
}

部门对象

public class DeptEntity {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }

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

Xml相关配置

<!--内部bean -->
<bean id="empEntity" class="com.mayikt.entity.EmpEntity">
    <!--设置属性name/age -->
    <property name="name" value="mayikt"></property>
    <property name="age" value="21"></property>
    <!-- 嵌入部门bean-->
    <property name="deptEntity">
        <bean id="deptEntity" class="com.mayikt.entity.DeptEntity">
            <property name="name" value="教育部门"></property>
        </bean>
    </property>

</bean>

3.3.7、注入级联赋值

写法1

<bean id="empEntity" class="com.mayikt.entity.EmpEntity">
    <!--两个属性-->
    <property name="name" value="mayikt"></property>
    <property name="addres" value="湖北省武汉市"></property>
    <!--级联赋值-->
    <property name="deptEntity" ref="deptEntity"></property>
</bean>
<bean id="deptEntity" class="com.mayikt.entity.DeptEntity">
    <property name="name" value="教育部门"></property>
</bean>

写法2

<bean id="empEntity" class="com.mayikt.entity.EmpEntity">
    <!--两个属性-->
    <property name="name" value="mayikt"></property>
    <property name="addres" value="湖北省武汉市"></property>
    <!--级联赋值-->
    <property name="deptEntity" ref="deptEntity"></property>
    <property name="deptEntity.name" value="教育部门"></property>
</bean>
<bean id="deptEntity" class="com.mayikt.entity.DeptEntity">
</bean>

注意：需要在员工实体类新增：deptEntity get方法。

3.3.8、注入集合类型属性

1. 注入数组类型

2. 注入list集合类型

3. 注入Map集合类型属性

4. 注入set集合属性

实体类

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class StuEntity {
    //1.数组属性
    private String[] arrays;
    //2.list集合属性
   private List<String> list;
    //3.Map
    private Map<String,String> map;
    //4.Set
    private Set<String> set;

    public void setArrays(String[] arrays) {
        this.arrays = arrays;
    }

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

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

    public void setSet(Set<String> set) {
        this.set = set;
    }

    @Override
    public String toString() {
        return "StuEntity{" +
                "arrays=" + Arrays.toString(arrays) +
                ", list=" + list +
                ", map=" + map +
                ", set=" + set +
                '}';
    }
}

配置文件

<bean id="stuEntity" class="com.mayikt.entity.StuEntity">
    <!--数组类型注入-->
    <property name="arrays">
        <array>
            <value>mayikt01</value>
            <value>mayikt02</value>
        </array>
    </property>
    <!--list-->
    <property name="list">
        <list>
            <value>语文</value>
            <value>数学</value>
        </list>
    </property>
    <!--Map-->
    <property name="map">
       <map>
           <entry key="张三丰" value="23"></entry>
           <entry key="小薇" value="25"></entry>
       </map>
    </property>
    <!--Set-->
    <property name="Set">
       <set>
           <value>01</value>
           <value>02</value>
       </set>
    </property>
</bean>

集合类型为对象

private List<CourseEntity> courses;
public void setCourses(List<CourseEntity> courses) {
    this.courses = courses;
}

public class CourseEntity {
    private String name;

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

    @Override
    public String toString() {
        return "CourseEntity{" +
                "name='" + name + '\'' +
                '}';
    }
}
<?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="stuEntity" class="com.mayikt.entity.StuEntity">
        <!--对我们的list属性赋值-->
        <property name="list">
            <list>
                <value>list01</value>
                <value>list02</value>
            </list>
        </property>
        <!--对我们的arrays属性赋值-->
        <property name="arrays">
            <array>
                <value>mayikt01</value>
                <value>mayikt02</value>
            </array>
        </property>
        <!--对我们的map属性赋值-->
        <property name="map">
            <map>
                <entry key="mayikt" value="张三丰"></entry>
                <entry key="xiaowei" value="小薇"></entry>
            </map>
        </property>
        <!--对我们的set属性赋值-->
        <property name="set">
            <set>
                <value>list01</value>
                <value>list02</value>
            </set>
        </property>
        <property name="courses" >
            <list>
                <ref bean="courseEntity1"></ref>

集合注入部分提取公共

1. 需要先引入一个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">

2. 使用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">

    <!-- 提取公共部分-->
    <util:list id="list">
        <value>mayikt01</value>
        <value>mayikt02</value>
    </util:list>
    <bean id="stuEntity" class="com.mayikt.entity.StuEntity">
        <property name="list" ref="list"></property>
    </bean>
</beans>

3.3.9、IOC操作Bean的管理

1. Spring中两种类型bean，一种是为普通的bean，另外一种是工厂bean

FactoryBean

2. 普通Bean：在配置文件中定义什么类型与返回的类型需一致；

3. 工厂Bean：在配置文件中定义Bean类型与返回类型可以不一致；

创建一个类，这个类是为工厂Bean，实现FactoryBean接口

import com.mayikt.entity.UserEntity;
import org.springframework.beans.factory.FactoryBean;

public class MayiktBean implements FactoryBean<UserEntity> {
    /**
     * 定义返回bean
     *
     * @return
     * @throws Exception
     */
    public UserEntity getObject() throws Exception {
        return new UserEntity();
    }

    public Class<?> getObjectType() {
        return null;
    }
}
public static void main(String[] args) {
    ClassPathXmlApplicationContext app =
            new ClassPathXmlApplicationContext("spring_08.xml");
    UserEntity mayiktBean = (UserEntity) app.getBean("mayiktBean");
    System.out.println(mayiktBean);
}

3.4、Spring的工厂Bean

3.4.1、SpringBean的作用域

什么是作用域？

设定bean作用域是为单例还是多例

作用域单例与多例有什么区别呢？

1. 单例的作用域：每次在调用getbean方法获取对象都是为同一个对象；

2. 多例的作用域：每次在调用getbean方法获取对象都是一个

新的对象。

注意：在spring默认的情况下，bean的作用域就是为单例 节约服务器内存。

单例：

在同一个jvm中，该bean对象只会创建一次。

多例：

在同一个jvm中，该bean对象可以被创建多次。

设定对象单例还是多例

在spring的默认的情况下，springbean的作用域为单例。

1.单例就是每次获取bean都是同一个对象；

2.多例就是每次获取bean都是新的一个对象；

单例：在同一个jvm中该bean只能存在一个实例；

多例子：在同一个jvm中该bean存在多个实例；

证明：如果是为单例，则两个对象地址都是一样的，

多例子对象则两个对象地址不一样。

单例配置：

<bean id="userEntity" class="com.mayikt.entity.UserEntity" scope="singleton"></bean>

默认就是为单例子；

多例配置：

<bean id="userEntity" class="com.mayikt.entity.UserEntity" scope="prototype"></bean>

3.4.2、SpringBean的生命周期

简单分为：实例化→属性赋值→初始化→销毁

生命周期概念：

1. 对象的创建与销毁的过程，类似之前学习servlet生命的周期过程。

生命周期的原理：

1. 通过构造函数创建bean对象（默认执行无参构造函数 底层基于反射实现）

2. 为bean的属性设置 （使用反射调用set方法）

3. 调用bean的初始化的方法（需要单独在类中配置初始化的方法）

4. 正常使用bean对象

5. Spring容器关闭，调用该类的销毁回调的方法（需要单独在类中配置销毁的方法）

public class MemberEntity {
    private String name;
    public MemberEntity(){
        System.out.println("[第一步]-无参构造函数被执行---反射机制调用");
    }

    public void setName(String name) {
        System.out.println("[第二步]-set方法初始化属性---反射机制调用");
        this.name = name;
    }

    /**
     * 回调调用init初始化方法
     */
    public void initMethod(){
        System.out.println("[第三步]-回调调用init初始化方法");
    }

    /**
     * destroyMethod
     */
    public void destroyMethod(){
        System.out.println("[第五步]-回调调用destroyMethod方法");
    }
}
<bean id="memberEntity" class="com.mayikt.entity.MemberEntity" init-method="initMethod" destroy-method="destroyMethod">
   <property name="name" value="mayikt"></property>
</bean>
<bean id="mayiktBeanPost" class="com.mayikt.bean.MayiktBeanPost"></bean>
import com.mayikt.entity.MemberEntity;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test07 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext app =
                new ClassPathXmlApplicationContext("spring_07.xml");
       MemberEntity memberEntity= app.getBean("memberEntity",MemberEntity.class);
        System.out.println("[第四步]-获取使用到的memberEntity");
        System.out.println(memberEntity);
        // 手动让bean容器销毁
        app.close();
    }
}

Bean的后置处理器 作用提供更多的扩展功能 BeanPostProcessor

相关演示代码

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

public class MayiktBeanPost implements BeanPostProcessor {
    /**
     * 调用初始化方法之前执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在bean 初始化方法之前执行");
        return bean;
    }

    /**
     * 调用初始化方法之后执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在bean 初始化方法之后执行");
        return bean;
    }
}
<bean id="mayiktBeanPost" class="com.mayikt.bean.MayiktBeanPost"></bean>

1.通过构造函数创建bean对象（默认执行无参构造函数 底层基于反射实现）

2.为bean的属性设置 （使用反射调用set方法）

3.将bean传递给后置处理器 调用初始化方法之前执行

4.调用bean的初始化的方法（需要单独在类中配置初始化的方法）

5.将bean传递给后置处理器 调用初始化方法之后执行

6.正常使用bean对象

7.Spring容器关闭，调用该类的销毁回调的方法（需要单独在类中配置销毁的方法）

后置处理器底层原理

配置多个BeanPostProcessor

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

public class MayiktBeanPost implements BeanPostProcessor, Ordered {
    /**
     * 调用初始化方法之前执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("调用该bean的 init方法之前");
        return bean;
    }

    /**
     * 调用初始化方法之后执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("调用该bean的 init方法之后");
        return bean;
    }

    public int getOrder() {
        return 1;
    }
}
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.core.Ordered;

public class MayiktBeanPost02 implements BeanPostProcessor, Ordered {
    /**
     * 调用初始化方法之前执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("[MayiktBeanPost02:]调用该bean的 init方法之前");
        return bean;
    }

    /**
     * 调用初始化方法之后执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("[MayiktBeanPost02:]调用该bean的 init方法之后");
        return bean;
    }

    public int getOrder() {
        return 0;
    }
}
<!-- 后置处理器-->
<bean id="mayiktBeanPost" class="com.mayikt.bean.MayiktBeanPost"></bean>
<bean id="mayiktBeanPost02" class="com.mayikt.bean.MayiktBeanPost02"></bean>

实现Ordered接口 getOrder 值越小越优先加载

3.4.3、SpringBean的自动装配

什么是自动装配呢

根据装配的规则（属性的名称或者属性的类型）

Spring根据装配的规则自动为属性注入值。

1. 什么是自动装配

A. 根据指定装配规则（属性名称或者属性的类型），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">

    <!-- spring ioc     <bean id="empEntity" class="com.mayikt.entity.EmpEntity">
        <property name="deptEntity" ref="deptEntity"></property>
    </bean> -->

    <!-- bean 标签中有一个属性autowire
         1.根据属性的名称注入 bean的id名称与属性的名称一致
         2.根据属性的类型注入 bean的类型与属性类型一致
      -->
    <bean id="empEntity" class="com.mayikt.entity.EmpEntity" autowire="byType">

    </bean>
    <bean id="deptEntity" class="com.mayikt.entity.DeptEntity">
        <property name="name" value="教育部门"></property>
    </bean>
  
</beans>

3.4.4、SpringBean的外部属性文件

3.5、SpringBean的注解形式

3.5.1、Spring的注解启动方式

Bean的管理操作方式

1. 基于XML方式实现

2. 基于注解方式实现

什么是注解：注解是JDK5中推出的新特性，代码的特殊标记，

格式注解名称“属性名称=属性值，属性名称=属性值”。

我们在后期学习springboot开发基本上都是使用注解，很少在使用

Xml配置的方式。

注解可以使用在类、方法、属性、上面。

使用注解的目的，简化xml的配置方式。

Spring提供的常用注解

1. @Component 将对象注入Spring容器中

2. @Service 注入业务逻辑对象

3. @Controller 控制器类

4. @Repository 注入dao对象

5. 以上该四个注解底层都是基于@Component注解封装的，只是区分用于

在不同的场景下。

注解的使用方式

AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext();
app.register(BeanConfig.class);
app.refresh();
MemberEntity  memberEntity = (MemberEntity) app.getBean("memberEntity");
System.out.println(memberEntity);

出世&入世
关注
专栏目录
零基础学JavaWeb开发：JSPServletStrutsSpringHibernateAjax
07-22
资源名称：零基础学Java Web 开发：JSP Servlet Struts Spring Hibernate Ajax内容简介：本书分为3篇共17章。其中，第1～12章是基础篇，介绍了Java Web开发中必不可少的各种基础知识；第13～16章是进阶篇，主要讲解...
JavaWeb开发之Spring+SpringMVC+MyBatis+SpringSecurity+EhCache+JCaptcha 完整Web基础框架
08-31
在JavaWeb开发中，构建一个完整的Web基础框架是非常重要的，因为它可以提高开发效率，提供良好的架构，便于维护和扩展。本篇文章将详细讲解基于Spring、SpringMVC、MyBatis、SpringSecurity、EhCache和JCaptcha这六...
11.JavaWeb-Spring框架
LB_bei的博客
06-13 1081
而IOC的思想是将对象的创建和依赖关系的管理交给框架来完成，从而实现解耦、灵活和可扩展的设计。耦合就是联系的紧密程度，一方面，紧密耦合的代码难以测试、难以复用、难以理解，经常修复一个bug，出现一个或者更多新的bug另一方面，一定程度的耦合又是必须的，完全没有耦合的代码什么也做不了。1.有时一段代码可能会重复出现在多个组件中，当你想改变这段代码时，必须修改各个组件中的相关实现，就算把这段代码封装起来，其他组件只是调用他的方法，但方法的调用还是会重复出现在各个组件中。
JavaWeb开发框架——Spring
weixin_44623055的博客
03-12 4485
1、Spring简介 1.1、Spring是什么 Spring是分层的Java SE/EE 应用full-stack轻量级开源框架，以IoC（Inverse Of Control：反转控制）和AOP（Aspect Oriented Programming：面向切面编程）为内核。 提供了展现层SpringMVC和持久层Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的JavaEE企业应用开源框架。 .......
JavaWeb后端开发Spring框架之消息 消息队列案例--订单短信通知
我见玫瑰生于荆棘之上
06-23 6462
当涉及使用Spring框架进行消息队列的订单短信通知时，你可以考虑以下步骤和实现方法： 1. 确定技术栈和工具 首先，你需要选择合适的消息队列技术。常见的选择包括： Apache Kafka RabbitMQ ActiveMQ 这些消息队列系统都能够与Spring框架很好地集成，并且有广泛的社区支持和文档资源。 2. 配置消息队列 选择一个消息队列系统并设置好你的消息队列服务器。确保你有权限访问该队列，以便生产和消费消息。 3. 创建订单服务 创建一个Spring服务来处理订单相关的逻辑。这可能包括
从JavaWeb基础到Spring学习的思考
key_768的博客
04-30 628
前言 到了现在，SpringFramework已经成为了后端必须学习的框架 曾经就简单的学习了SSM（Spring+SpringMVC+Mybaits）的组合，和同学一起开发了一个漏洞百出的项目 发现，对SSM框架的一直停留在配置使用的阶段 Spring太傻瓜式了，导好包，配置个xml，写点业务，Spring集成一下Mybatis（还是导个包），连接数据库配置一下，写点sql语句，就完成了SSM框...
JavaWeb开发框架——Spring练习
weixin_44623055的博客
03-18 1319
1、Spring练习环境搭建 1.1、Spring环境搭建步骤 创建工程（Project & Module）； 导入静态页面； 导入需要坐标； 创建包结构（controller、service、dao、domain、utils）； 导入数据库脚本； 创建POJO类； 创建配置文件（applicationContext.xml、spring-mvc.xml、jdbc,properties、log4j.properties）。 pom.xml: ... <depend
JavaWeb开发框架——SpringMVC
weixin_44623055的博客
03-15 2697
1、SpringMVC概述 SpringMVC是一种基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架，属于SpringFrameWork的后续产品，已经融合在Spring Web Flow中。 SpringMVC已经成为目前最主流的MVC框架之一，并且随着Spring 3.0 的发布，全面超越Struts2，成为最优秀的MVC框架。它通过一套注解，让一个简单的Java类称为处理请求的控制器，而无需实现任何接口。同时，他还支持RESTful编程风格的请求。 2、SpringMVC快速入门
【Java学习路线之JavaWeb】Spring MVC框架入门教程
qq_41854911的博客
02-05 2631
【Java学习路线之JavaWeb】Spring MVC框架入门教程 文章目录【Java学习路线之JavaWeb】Spring MVC框架入门教程读者阅读条件MVC设计模式简介JSP+JavaBeanServlet+JSP+JavaBeanMVC优缺点优点缺点Spring MVC是什么Spring MVC优点第一个Spring MVC程序1. 创建Web应用并引入JAR包2. Spring MVC配置1）定义DispatcherServlet2）创建Spring MVC配置文件3. 创建Controller
javaWeb快速开发框架之Play
no problem的博客
04-09 3720
play framework——一个全栈的高度封装的web快速开发框架，能提升开发效率，感兴趣可以来看一看！
【Java学习路线之JavaWeb】Spring Cloud教程（非常详细）
qq_41854911的博客
02-05 8033
文章目录读者阅读条件微服务是什么微服务，我们可以从字面上去理解，即“微小的服务”，下面我们从“服务”和“微小”两个方面进行介绍。微服务架构微服务架构 vs 单体架构微服务的特点微服务框架Java 微服务框架Go 语言微服务框Phyton 微服务框架NodeJS微服务框架Spring Cloud是什么Spring Cloud 常用组件Spring Boot 和 Spring Cloud 的区别与联系1. Spring Boot 和 Spring Cloud 分工不同2. Spring Cloud 是基于 Sp
JavaWeb快速开发框架——Spring Blade集成框架（快速上手）！
热门推荐
MaNongXf的博客
11-02 5万+
说起Spring Blade集成框架也许很多人甚至都没有听说过（虽然我在来目前这家公司前也没有听说过，因为这是码云上的一个大神写的开源项目，传送门），刚开始我都有点怀疑人生了，不是SSM也不是SSH更不是Spring boot,就这个听都没听说过的框架还有企业专门用它作为核心框架开发？我就呵呵了。。 用了一个月后。。。真香！ 好了，首先来简单的介绍一下Spring Blade SpringB...
轻松学JavaWeb开发之Spring框架入门PPT学习教案.pptx
10-03
本资源摘要信息是关于轻松学JavaWeb开发之Spring框架入门PPT学习教案的知识点总结。 1. Spring概述：Spring是一种非常完整的技术，可以实现项目的开发。Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的...
spring 轻量级Javaweb开发框架
05-19
Spring框架是Java Web开发中的一个核心框架，被誉为“企业级应用开发的事实标准”。它以其轻量级、模块化的设计理念，极大地简化了Java应用程序的构建，尤其在Web应用开发领域中，Spring扮演着至关重要的角色。 ...
Javaweb开发学习路线及Java三大框架分享？共4页
10-30
JavaWeb开发学习路线是每一位Java开发者都需要关注的重要领域，它涵盖了从基础到进阶的一系列技术栈。在JavaWeb的世界里，三大框架Spring、Hibernate和Struts2是开发者们经常打交道的核心工具，它们极大地提高了开发...
springboot注册和注入组件方式概览
CamphorBlossom的博客
09-21 316
依赖：组件的依赖关系，如 NewsController 依赖 NewsServices。注入：通过setter方法、构造器、等方式自动的注入（赋值）控制：资源的控制权（资源的创建、获取、销毁等）xxxAware（标记接口，让调用者获取到Spring容器中的其他资源引用）反转：和传统的方式不一样了。理解单例，获取组件的方式（通过bean的类型，名称获取）理解setter方法注入，构造器注入。Conditional 派生注解。理解MVC分层模型对应注解。
Spring Data Rest 远程命令执⾏命令(CVE-2017-8046) 靶场攻略
最新发布
shw_yzh的博客
09-23 296
靶场环境靶场环境。
springboot acuturator
pscool的博客
09-21 276
基础使用步骤 - 系统学习。
Springboot 文件上传下载相关问题
quokka56的博客
09-21 539
Springboot 文件上传下载问题 保姆级教程
JavaWeb框架整合开发：Struts2, Hibernate, Spring实践
"该资源是‘轻松学JavaWeb开发之框架技术整合开发’主题的优秀PPT，旨在帮助读者理解并掌握JavaWeb开发中的框架整合技术，特别是Struts2、Hibernate和Spring三个主流框架的集成应用。" 在JavaWeb开发中，框架整合是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

出世&入世

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值