Spring入门

最新推荐文章于 2024-06-14 10:17:52 发布

想吃米豆腐

最新推荐文章于 2024-06-14 10:17:52 发布

阅读量89

点赞数

分类专栏： Java框架文章标签： spring java

本文链接：https://blog.csdn.net/weixin_50823456/article/details/120196310

版权

Java框架专栏收录该内容

5 篇文章 0 订阅

订阅专栏

spring官方网站：https://spring.io/

什么是Spring？

一个轻量级Java开发框架
解决企业级应用开发的复杂性，即简化Java开发。
为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题。

Spring的核心

依赖注入（dependency injection，DI）和面向切面编程（aspect-oriented programming，AOP）。
控制反转 IoC , 面向切面 Aop。
IoC容器和AOP模块。通过IoC容器管理POJO对象以及他们之间的耦合关系；通过AOP以动态非侵入的方式增强服务。

IoC让相互协作的组件保持松散的耦合，而AOP编程允许你把遍布于应用各层的功能分离出来形成可重用的功能组件。

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

案例：

1、导入依赖

 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>

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" xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--Spring 配置文件 主要用来创建对象 控制反转 ioc,一对标签 对应的对象在运行过程中 只创建一个,
    在tomcat启动的时候 就会创建出所有的对象-->
    <!--id是唯一的标识 有几个bean 就写几个  class中写路径-->
    <bean id="stu" class="com.bdqn.entity.Student">
        <!--value: 给基本数据类型赋值 还有String 赋值-->
        <property name="name" value="Joker"/>
        <property name="sex" value="男"/>
        <property name="age" value="18"/>
        <property name="like" value="男"/>
        <!--ref:给对象赋值-->
     <!-- <property name="school" ref="oriental"/>-->
    </bean>
    <bean id="handsome" class="com.bdqn.entity.Student" p:name="品" p:sex="不知道" p:age="40" p:like="富婆">
    </bean>
    <bean id="peking" class="com.bdqn.entity.School">
        <property name="schoolName" value="北京大学"></property>
        <!--constructor-arg:通过有参构造 创建对象    name:有参函数的名字-->
        <constructor-arg name="schoolName" value="北京大学"></constructor-arg>
        <property name="list">
            <!--注入集合数据  是什么集合 就叫什么名字-->
            <list>
                <ref bean="handsome"></ref>
            </list>
        </property>
    </bean>
    <bean id="oriental" class="com.bdqn.entity.School">
        <property name="schoolName" value="新东方"></property>
        <property name="list">
            <list>
                <ref bean="stu"></ref>
            </list>
        </property>
    </bean>
</beans>

3.实体类的编写

学生类
public class Student {
    private String name;
    private String sex;
    
    public Student(){
        System.out.println("创建学生");
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

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

    public String getLike() {
        return like;
    }

    public void setLike(String like) {
        this.like = like;
    }

    private Integer age;
    private String like;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                ", like='" + like + '\'' +
                '}';
    }
}

学校类
public class School {
    private String schoolName;

    public List<Student> getList() {
        return list;
    }

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

    private List<Student> list;

    public School(){
        System.out.println("创建学校");
    }

    public School(String schoolName) {
    }

    @Override
    public String toString() {
        return "School{" +
                "schoolName='" + schoolName + '\'' +
                ", list=" + list +
                '}';
    }

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
}

4.测试类的编写

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 江江江
 * @create 2021/9/9 9:35
 */
public class TestSpring {
    public static void main(String[] args) {
        //ApplicationContex：Spring容器(spring创建的对象都在这个容器中)
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("application.xml");
        //从spring容器中获得的对象就是通过依赖注入 依赖注入只能注入 spring容器中的对象
        //1、根据spring中对象名称注入对象
        Student stu= (Student) applicationContext.getBean("stu");
        //2、根据类型注入对下对象 如果spring 有两个相同的类型的对象 会报错
        //Student joker=applicationContext.getBean(Student.class);
        Student handsome= (Student) applicationContext.getBean("handsome");
        System.out.println(handsome);
        System.out.println(stu);
    }
}

注意：IOC创建对象方式：通过有参构造无参构造方法进行创建在以上代码注释中
1、常量注入

<bean id="student" class="com.kuang.pojo.Student">
<property name="name" value="小明"/>
</bean>

2、Bean注入

bean id="addr" class="com.kuang.pojo.Address">
<property name="address" value="重庆"/>
</bean>
<bean id="student" class="com.kuang.pojo.Student">
<property name="name" value="小明"/>
<property name="address" ref="addr"/>
</bean>

3、数组注入

<bean id="student" class="com.kuang.pojo.Student">
<property name="name" value="小明"/>
<property name="address" ref="addr"/>
<property name="books">
<array>
<value>西游记</value>
<value>红楼梦</value>
<value>水浒传</value>
</array>
</property>
</bean>

4、list注入

property name="hobbys">
<list>
<value>听歌</value>
<value>看电影</value>
<value>爬山</value>
</list>
</property>

5、map注入

<property name="card">
<map>
<entry key="中国邮政" value="456456456465456"/>
<entry key="建设" value="1456682255511"/>
</map>
</property>

6、set注入

<property name="games">
<set>
<value>LOL</value>
<value>BOB</value>
<value>COC</value>
</set>
</property>

7、Null注入

<property name="wife"><null/></property>

8、Properties注入

<property name="info">
<props>
<prop key="学号">20190604</prop>
<prop key="性别">男</prop>
<prop key="姓名">小明</prop>
</props>
</property>

@Autowired与@Resource异同：

@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。
@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果
要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我
们想使用名称装配可以结合@Qualifier注解进行使用
@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果
没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在
setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是
需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。
它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先
byName。

AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现
程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的
一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使
得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

1、导入依赖

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>

2、去spring的文件中注册 , 并实现aop切入实现

<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean-->
<bean id="userService" class="com.kuang.service.UserServiceImpl"/>
<bean id="log" class="com.kuang.log.Log"/>
<bean id="afterLog" class="com.kuang.log.AfterLog"/>
<!--aop的配置-->
<aop:config>
<!--切入点 expression:表达式匹配要执行的方法-->
<aop:pointcut id="pointcut" expression="execution(*
com.kuang.service.UserServiceImpl.*(..))"/>
<!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>

想吃米豆腐

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Spring入门

spring官方网站：https://spring.io/什么是Spring？一个轻量级Java开发框架解决企业级应用开发的复杂性，即简化Java开发。为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题。Spring的核心依赖注入（dependency injection，DI）和面向切面编程（aspect-oriented programming，AOP）。IoC容器和AOP模块。通过IoC容器管理POJO对象以及他们之间的耦合关系；通过AOP以动态非侵入的方式增强服务。IoC.
复制链接

扫一扫