Spring

最新推荐文章于 2024-11-17 23:49:21 发布
最新推荐文章于 2024-11-17 23:49:21 发布
阅读量157 收藏
点赞数
文章标签： spring java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52955421/article/details/127067043
版权

Spring

IOCxml配置文件开发

配置导入依赖

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-beans</artifactId>
  <version>5.3.1</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.3.1</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>5.3.1</version>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-autoconfigure</artifactId>
  <version>2.4.0</version>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot</artifactId>
  <version>2.4.0</version>
</dependency>

类型注入

<bean id="stu" class="collectionType.Stu">
<!--        数组类型注入-->
        <property name="courses">
            <array>
                <value>java课程</value>
                <value>数据库</value>
            </array>
        </property>

<!--        list属性-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>

<!--        map属性-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>

<!--        set属性-->
        <property name="sets">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>
<!--        list 值是对象-->
        <property name="course">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>

    </bean>
    <!--        创建多个course对象-->
    <bean id="course1" class="collectionType.Course">
        <property name="cname" value="框架"></property>
    </bean>
    <bean class="collectionType.Course" id="course2">
        <property name="cname" value="架构"></property>
    </bean>

<!--    提取list集合类型属性注入-->
    <util:list id="booklist">
        <value>易筋经</value>
        <value>九阴真经</value>
    </util:list>
<!--scope  singleton单实例 默认单实例 singleton在加载Spring配置文件时候创建对象
           prototype多实例对象,不在加载的时候创建对象,在调用getBean方法的时候创建-->
    <bean id="book" class="collectionType.Book" scope="prototype">
        <property name="list" ref="booklist"></property>
    </bean>
    <bean id="MyBean" class="Shang15.MyBean"></bean>

public class Stu {
    //数组类型属性
    private String[] courses;
    //list类型
    private List<String> list;
    //map类型;
    private Map<String,String> maps;
    //set类型
    private Set<String> sets;
    //学生所学多门课程
    private List<Course> course;

    public void setCourse(List<Course> course) {
        this.course = course;
    }

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

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

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

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

    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
        System.out.println(course);
    }
}

public class Book {
    private List<String> list;

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

级联赋值

<!--    1.service和dao对象的创建-->
    <bean id="userService" class="Oct29.Service.UserService">
<!--        注入userDao对象
              name属性：类里面属性名称
              ref属性：创建userDao对象bean标签id值
-->
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userDao" class="Oct29.dao.UserDaoImpl"></bean>

<!--  级联赋值  -->
    <bean id="emp" class="Oct29.bean.Emp">
<!--        设置俩个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
<!--        设置对象类型属性-->
        <property name="dept">
            <bean id="dept" class="Oct29.bean.Dept">
                <property name="dname" value="安保"></property>
            </bean>
        </property>
<!--        级联赋值-->
<!--        <property name="dept" ref="dept"></property>-->
    </bean>
<!--    <bean id="dept" class="Oct29.bean.Dept">-->
<!--        <property name="dname" value="财务部"></property>-->
<!--    </bean>-->

public class UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("service add");
        userDao.update();
    }
}


public class Emp {
    private String ename;
    private String gender;
//    员工输入某一个部门
    private Dept dept;
    public Dept getDept() {
        return dept;
    }
    public void setDept(Dept dept) {
        this.dept = dept;
    }

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



    public void add() {
        System.out.println(ename + gender + dept);
    }
}

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

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

配置后置管理器和自动装配

<!--    配置后置处理器-->
    <bean id="myBeanPost" class="collectionType.MyBeanPost"></bean>

<!--    实现自动装配
        bean标签属性autowire,配置自动装配
        autowire属性值常用俩值
        byName根据名称注入 ,注入值bean的id值和类属性一样
        byType根据属性类型注入 -->
    <bean id="emp" class="autowire.Emp" autowire="byType">
<!--        <property name="dept" ref="dept"></property>-->
    </bean>
    <bean id="dept" class="autowire.Dept"></bean>

public class orders {
    private String oname;

    public orders() {
        System.out.println("第一步 执行无参数构造创建bean实例");
    }

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用set方法设置属性值");
    }

    //创建执行的初始化的方法
    public void initMethod(){
        System.out.println("第三步 执行初始化方法");
    }
    //创建执行的销毁的方法
    public void destoryMethod(){
        System.out.println("第五步 执行销毁方法");
    }
}

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //后置处理器
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}

设置空值，特殊字符，有参构造注入属性，p名称空间注入

<!-- 设置空值-->
<!--        <property name="author">-->
<!--            <null></null>-->
<!--        </property>-->
<!-- 含有特殊字符
            1.把特殊字符转义&gt;或者&lt;
            2.<![CDATA[]]>
-->
<!--        <property name="author">-->
<!--            <value><![CDATA[<<南京>>]]></value>-->
<!--        </property>-->
    </bean>
<!--    有参数构造注入属性-->
    <bean id="order" class="Orders">
        <constructor-arg name="oname" value="abc"></constructor-arg>
        <constructor-arg name="address" value="china"></constructor-arg>

    </bean>
<!--    p名称空间注入-->
<!--    <bean id="book" class="Book" p:author="jj" p:book="西游"></bean>-->

IOC注解开发

配置类代替xml配置文件

@Configuration //作为配置类，代替xml配置文件
@ComponentScan(basePackages = {"config","service","dao"})//扫描哪些包
public class SpringConfig {

}

开启组件扫描

<!--    开启组件扫描
        1,扫描多个包用逗号隔开
        2,扫描包上层目录-->
    <context:component-scan base-package="service,dao"></context:component-scan>

设置扫描内容

<!--  实例1
      use-default-filters="false"  表示不使用默认filter,自己配置filter
      context:include-filter 设置扫描那些内容
      expression="org.springframework.stereotype.Controller只扫描controller类-->

<context:component-scan base-package="service,dao" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!--  实例2
  context:include-filter 设置扫描那些内容
  不扫描controller类-->

<context:component-scan base-package="service,dao" >
    <context:exclude-filter  type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

实体类及测试

@Test
public void testService2(){
    ApplicationContext context=new AnnotationConfigApplicationContext(config.SpringConfig.class);
    UserService userService=context.getBean("userService",UserService.class);

    System.out.println(userService);
    userService.add();
}

//在注解里面value属性值可以省略
//默认值是类名称，首字母小写
//UserService -- userService
//@Component(value = "userService")//<bean id="" class="">

//@Service

@Controller
public class UserService {
    //定义dao
    //不需要添加set方法
    //添加属性注解
    @Autowired //根据类型进行注入
    @Qualifier(value = "userDaoImpl1")  //根据名称注入，多个同类型不知道找哪个,要跟着Autowired一起使用
    private UserDao userDao;

    public void add(){
        System.out.println("service add...");
        userDao.add();
    }
}

AOPxml配置文件开发

反射机制

public class JDKProxy {
    public static void main(String[] args) {
        Class[] interfaces= {UserDao.class};
//        UserDao dao=(UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
//            @Override
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                return method.invoke(new UserDaoImp1(),args);
//            }
//        });
        UserDaoImp1 userDao=new UserDaoImp1();
        UserDao dao=(UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,new  UserDaoProxy(userDao));
        int result=dao.add(1,2);
        System.out.println(result);
        System.out.println(dao.update("asd"));
    }
}
class UserDaoProxy implements InvocationHandler{
    private Object obj;
    //有参数构造的传递
    public UserDaoProxy(Object obj){
        this.obj=obj;
    }

    //增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前执行
        System.out.println("方法之前执行..."+method.getName()+":传递的参数..."+ Arrays.toString(args));

        //被增强的方法执行
        Object res = method.invoke(obj,args);

        //方法之后
        System.out.println("方法之后..."+obj);


        return res;
    }
}

public class UserDaoImp1 implements UserDao {
    @Override
    public int add(int a, int b) {
        System.out.println("add方法执行嘞");
        return a+b;
    }

    @Override
    public String update(String id) {
        System.out.println("update方法执行嘞");
        return id;
    }
}

配置aopxml

<!--    开启Aspect生成带理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<bean id="user" class="aopanno.User"  ></bean>
<bean id="userProxy" class="aopanno.UserProxy"></bean>
<aop:config>
    <aop:aspect id="aspect" ref="userProxy">
        <aop:pointcut id="cut" expression="execution(* aopanno.User.add(..))"/>
        <aop:after method="after" pointcut-ref="cut"></aop:after>
        <aop:before method="before" pointcut-ref="cut"></aop:before>
    </aop:aspect>
</aop:config>

@Component
public class User {
    public void add(){
        System.out.println("add....");
    }


}

public class UserProxy {

    //相同切入点抽取
    @Pointcut(value = "execution(* aopanno.User.add(..))")
    public void pointdemo(){

    }


    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("before...");
    }
    //最终通知
    @After(value = "execution(* aopanno.User.add(..))")
    public void after(){
        System.out.println("after...");
    }
    //异常通知
    @AfterThrowing(value = "execution(* aopanno.User.add(..))")
    public void afterthrowing() {
        System.out.println("afterthrowing...");

    }
    //环绕通知
    @Around(value = "execution(* aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("aroundbefore...");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("aroundafter...");
    }
    //后置通知
    @AfterReturning(value = "execution(* aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning...");

    }
}

AOP注解开发

开启组件扫描

<context:component-scan base-package="aopanno"></context:component-scan>

@Configuration
@ComponentScan(basePackages = {"aopanno"})
@EnableAspectJAutoProxy(proxyTargetClass = true)//默认是false false jdk代理
public class ConfigAop {

}

@Configuration
@ComponentScan(basePackages = {"aopanno"})
public class Aspect {
}

实体类及测试

@Component
@Aspect
@Order(1)//数值越小优先级越高
//增强类
public class UserProxy {

    //相同切入点抽取
    @Pointcut(value = "execution(* aopanno.User.add(..))")
    public void pointdemo(){

    }


    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("before...");
    }
    //最终通知
    @After(value = "execution(* aopanno.User.add(..))")
    public void after(){
        System.out.println("after...");
    }
    //异常通知
    @AfterThrowing(value = "execution(* aopanno.User.add(..))")
    public void afterthrowing() {
        System.out.println("afterthrowing...");

    }
    //环绕通知
    @Around(value = "execution(* aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("aroundbefore...");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("aroundafter...");
    }
    //后置通知
    @AfterReturning(value = "execution(* aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning...");

    }
}

@Test
public void testAopanno(){
    ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
    User user=context.getBean("user",User.class);
    user.add();
}
qq_52955421
关注
spring security原理和机制 | Spring Boot 35
学Java，找哪吒
06-25 5万+
一、SpringSecurity 框架简介 Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。 正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring
Spring监听器
骑个小蜗牛的博客
12-13 1万+
事件监听概念 应用程序事件允许我们发送和接收特定事件，我们可以根据需要处理这些事件。事件用于在松散耦合的组件之间交换信息。由于发布者和订阅者之间没有直接耦合，因此可以在不影响发布者的情况下修改订阅者，反之亦然。 事件监听三要素 事件源：事件对象的产生者，任何一个事件都有一个来源 ApplicationEvent 事件监听器：事件框架或组件收到一个事件后，需要通知所有相关的事件监听器来进行处理。这些监听器统一存储在事件监听器注册表中。 ApplicationListener（编码式事件监听器） @Event
Spring框架
m0_51457307的博客
11-20 1万+
一、Spring概述 Spring 是目前主流的 Java Web 开发框架，是 Java 世界最为成功的框架。该框架是一个轻量级的开源框架，具有很高的凝聚力#%E4%B8%80%E3%80%81Spring%E6%A6%82%E8%BF%B0和吸引力。
Spring Profiles详解
白石的专栏
03-11 7847
Profiles是Spring框架的核心功能——**允许我们将 bean 映射到不同的Profile**——例如，*dev*、*test* 和 *prod*。
Spring+Quartz实现定时任务的配置方法
热门推荐
yjclsx的博客
07-31 42万+
&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.spring
【Spring篇】Spring整合
Javascript_tsj的博客
05-04 9913
一、一、在准备环境的过程中，我们也来回顾下Mybatis开发的相关内容Mybatis是来操作数据库表，所以先创建一个数据库及表项目的pom.xml添加相关依赖resources目录下添加，用于配置数据库连接四要素useSSL:关闭MySQL的SSL连接。
Spring Cloud 微服务项目实战 -
小工匠
11-15 4万+
Milestone 版本：在大版本正式发布前的里程碑版本，例如 2021.0.0-M1，M1 代表当前大版本的第一个里程碑版本，M2 代表第二个迭代里程碑，以此类推。使用模板的好处是可以对优惠券消费规则做一层抽象，比如满减类、打折类这些优惠券只是具体的优惠金额不同，但是玩法类似，把相类似的玩法功能抽象成一个模板，就可以简化具体优惠券的创建和核销流程。建议： 当框架有重大版本更新时，建议你先按兵不动，等大版本做了一两次迭代之后，明显的 Bug 修复得差不多了了，再应用到项目中也不迟。
Spring Framework版本升级
pany_2017的博客
04-15 1万+
项目中spring framework版本升级
spring cloud搭建教程
ANGEL CITY
04-26 5万+
Spring cloud是一个基于Spring Boot实现的服务治理工具包,在微服务架构中用于管理和协调服务的微服务:就是把一个单体项目,拆分为多个微服务,每个微服务可以独立技术选型,独立开发,独立部署,独立运维.并且多个服务相互协调,相互配合,最终完成用户的价值. Spring Cloud是一系列框架的有序集合。其主要的设施有，服务发现与注册，配置中心，消息总线，负载均衡，断路器，数据监控等，通过Spring Boot的方式，可以实现一键启动，和部署。
SpringCloud 网关 Gateway
程序猿追的博客
11-29 1万+
spring-cloud-gateway是一个库，可以在spring webflux之上建立一个API网关，它的目的是提供一个简单，有效的方式去路由到APIS并且提供：安全、监控和弹性。gateway构建于spring boot2.x，spring webFlux，and Project Reactor，所以，许多同步库如spring Data和spring security不适用于gateway项目中。因为gateway是异步非阻塞的。 gateway要求spring boot和spring webFl
Spring6全面详解
weixin_45710998的博客
03-01 3647
　 自2022年11月，Spring6正式发布。在Spring6中，对于JDK的要求最低为 17+。（17 - 19） 部分文本摘抄于尚硅谷视频（bilibili）做了一定的排版和个人的理解。如果不是很熟悉，可以去看 [Spring5全面详解](http://t.csdn.cn/FgTQ7) 内容大约十万字左右， 对于Spring5的使用整理的较为全面，也都有解释部分，Spring6只是看以下是否具有一些特性上的更换。所以可能并没有Spring5的内容详细。但本篇大约在8-10万字左右。
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
SpringMVC+Spring+Mybatis集成开发环境
04-28
在IT行业中，SpringMVC、Spring和Mybatis是三大核心框架，它们的集成使用是Java Web开发中的常见实践。这个集成开发环境旨在提供一个高效、灵活的开发平台，以实现业务逻辑与数据访问的分离，提高代码的可维护性和可...
最新版本的Struts2+Spring4+Hibernate4框架整合
10-15
项目原型：Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6 二、 项目目的： 整合使用最新版本的三大框架（即Struts2、Spring4和Hibernate4），搭建项目架构原型。 项目架构原型：Struts2.3.16 + Spring4.1.1 + ...
Spring IOC容器简介
将军不下马，各自奔前程
11-15 370
依赖注入 (DI) 是 IoC 的一种特殊形式，对象通过构造函数参数、工厂方法的参数或在对象实例构造或从工厂方法返回后属性的set方法来定义其依赖关系（即它们使用的其他对象）。org.springframework.beans 和 org.springframework.context 包是 Spring Framework 的 IoC 容器的基础。在 Spring 中，构成应用程序架构并由 Spring IoC 容器管理的对象称为 bean。Bean 以及它们之间的依赖关系反映在容器使用的配置元数据中。
javax.mail-SpringBoot实现邮件发送
张刚的博客
11-14 365
javax.mail实现邮件发送 SpringBoot邮件发送 1、邮件发送环境准备 2、POP3/IMAP/SMTP协议区别 3、java实现邮件发送 工具类可以开箱即用，工具类很全面，支持以下几点： 1、支持抄送人 2、支持密送人 3、支持附件 4、支持html格式的邮件
基于Java Springboot二手家电管理平台
源码好优多
11-17 247
项目编号：springbootA080时代在飞速进步，每个行业都在努力发展现在先进技术，通过这些先进的技术来提高自己的水平和优势，二手家电管理平台当然不能排除在外。二手家电管理平台是在实际应用和软件工程的开发原理之上，运用java语言以及前台VUE框架，后台SpringBoot框架进行开发。首先要进行需求分析，分析出二手家电管理平台的主要功能，然后设计了系统结构。整体设计包括系统的功能、系统总体结构、系统数据结构和对系统安全性进行设计；
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 954
Rest请求处理
SpringBoot多环境配置的实现
最新发布
lazysnail的博客
11-17 700
开发过程中必然使用到的多环境案例，通过简单的案例分析多环境配置的实现过程。
Spring Boot入门指南
"Spring Boot官方文档" Spring Boot是一款由Pivotal团队开发的Java框架，其设计目的是简化Spring应用的初始搭建以及开发过程。通过自动配置、起步依赖和运行时整合，Spring Boot使得创建独立的、生产级别的基于...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值