Spring入门

最新推荐文章于 2021-01-03 20:23:52 发布
最新推荐文章于 2021-01-03 20:23:52 发布
阅读量117 收藏
点赞数

 

 

Spring优势（作用）

（1）Spring是一站式框架，因为Spring框架的性质是属于容器性质，容器中装了什么对象就有什么功能，所以可以一站式。

（2）不仅不排斥其他框架、还能其他框架帮忙管理对象。

（3）AOP支持

（4）基于IOC思想

（5）Spring jdbc

（6）aop 事务

（7）Junit测试支持。

 

Spring框架搭建（入门）

 

1、创建项目（Maven）

修改Maven配置

2、导包（pom.xml）

 

3、创建对象（User）

public class User {
    private Integer userId;
    private String name;
    private String password;

}

 

4、书写配置：注册对象到容器中

 

配置文件名字和目录问题：

文件名和目录都可以任意

建议：src/applicationContext.xml

 

在pom.xml中加入依赖：

 <!-- spring包 core、web、oxm、tx、jdbc、webmvc、aop、context、test -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

 

导入约束

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
							http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
							http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
							http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">



</beans>

将User对象交给Spring管理

<bean name="user" class="com.huadian.a_helloworld.User"></bean>

测试一下

创建一个Demo类；

    @Test
    public void fun(){
         ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User) ac.getBean("user");
        System.out.println(user);
    }

输出显示：

 

Spring概念

1.Spring思想

 

IOC：（Inverse of control） 反转控制

将我们创建对象的方式反转了。

以前对象的创建由我们开发人员自己维护，包括依赖关系也是我们自己注入的

使用Spring之后，对象的创建以及依赖关系可以由Spring完成创建以及注入

反转控制：就是反转了对象创建的方式，从我们自己创建反转给了程序（Spring）

 

DI：Dependency Injection 依赖注入

 

注入的方式：

set方法注入；先为属性添加set方法，然后如下：

    <bean name="car" class="com.huadian.c_injection.Car">
        <property name="name" value="公交车"></property>
    </bean>

name为添加的set方法名后面所对应的属性。 

如果通过set方法注入属性，那么spring会通过默认的空参构造方法来实例化对象，所以如果在类中写了一个带有参数的构造方法，一定要把空参数的构造方法写上，否则spring没有办法实例化对象，导致报错。

 

构造方法注入；需要为类添加好构造函数，

<bean name="user" class="com.huadian.c_injection.User">
    <constructor-arg name="name" value="123"></constructor-arg>
    <constructor-arg name="car" ref="car"></constructor-arg>
</bean>

 

注解的方式注入：

先在配置文件中配置：

xmlns:p="http://www.springframework.org/schema/p"

<bean name="user" class="com.huadian.c_injection.User"
        p:name="huadian"
        p:car-ref="car"></bean>

2.Spring中工厂（容器）

工厂factory

设计模式，提供的方法一般是静态的，

帮我们生产出对象的。

如：User user = XXXFactory.createUser();

 

ApplicationContext和BeanFactory

 

 BeanFactory：Spring原始接口，针对原始接口的实现类功能较为单一

该接口是在获取对象的时候才会创建对象。空间换时间。

BeanFactory的子接口，其常用实现类是org.springframework.context.support.FileSystemXmlApplicationContext和org.springframework.context.support.ClassXmlAplicationContext。
 

ApplicationContext：容器在创建的时候，容器里面配置的所有对象会被创建，并且提供更多的功能。时间换空间。

有2个实现类：

ClassPathXmlApplicationContext

从类路径加载配置文件

new ClassPathXmlApplicationContext( "applicationContext.xml" );

FileSystemXmlApplicationContext

从硬盘绝对路径中加载配置文件

New FileSystemXmlApplicationContext（“d:/xxx/yyy/zzz”）

 

一个算法的好与不好：时间复杂度和空间复杂度。

 

Spring配置详

 

Bean元素

Bean元素：使用该元素描述需要Spring容器管理的对象

class属性：被管理对象的完整类名。

name属性：给被管理的对象起的名字，获得对象时根据该name获取对象。（尽量使用）

id属性：功能与name属性一样，但是不能重复且不能使用特殊字符。（原始）

 

Bean元素的Scope属性：

 

Prototype:多例原型：将标记对象变成多例类型，每次获取的时候都创建一个新的对象

Singleton：单例（默认值）：将标记对象变成单例类型，每次获取的时候都创建对象都是同一个

Request

Web环境下，对象与Request生命周期一致

Session

Web环境下，对象与Session生命周期一致

Prototype

例：

@Repository("user")//dao层，实体层
@Scope("prototype")
public class User {
    @Value("111")
    private Integer userId;

    @Value("aaa")
    private String  name;
    private String  password;

先将user类标记成多例，

配置配置文件：

<context:component-scan base-package="com.huadian.d_annotion"></context:component-scan>
<bean name="car2" class="com.huadian.d_annotion.Car">
    <property name="name" value="gffs"></property>
</bean>

添加一个初始方法：

@PostConstruct//在对象别创建后调用 init-method
    public void init(){
        System.out.println("我是初始化方法！");
    }

 

测试类：

    @Test
    public void fun() {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext( "d_applicationContext.xml" );
        Object user1 = ac.getBean( "user" );
        Object user2 = ac.getBean( "user" );

        System.out.println( user1==user2);
    }

可以看到初始方法调用两次，说明创建了两个对象，user1和user2也不相同。 

Singleton

例:

@Scope("singleton")

设置成单例，也可以不设置，默认为单例。

方法只掉用了一次，并且user1==user2

说明这是同一个对象。

 

生命周期

init-method:指定初始化方法，spring在对象创建之后立即调用

destroy-method:指定摧毁方法，spring容器在关闭的时候 会销毁所有容器中的 对象之前调用

<bean name="user" class="com.huadian.a_helloworld.User" 
    init-method="init"
    destroy-method="destory">
</bean>

 这样可以在user类中添加init和destory方法。

 

Spring创建对象的方式（了解）

无参的构造方法 的方式

<bean name="user2" class="com.huadian.a_helloworld.User"></bean>-->

静态工厂实例化 的方式

  <!--将User对象交给Spring管理-->
    <bean name="user" class="com.huadian.b_create_bean.User" factory-method="getUserObject"></bean>

user类中

public class User {
    private Integer userId;
    private String  name;
    private String  password;  
 
     public User() {
        System.out.println("无参数构造方法");
    }

    public static User getUserObject() {
        System.out.println("静态工厂实例化方法");
        return null;
    }

Spring的分模块配置

将不同的模块配置放到不同的配置文件中。

每个配置文件都需要导入对应约束

ApplicationContext.xml

applicationContext-Dao.xml:所有DAO对象配置

applicationContext-Service.xml：所有Service对象配置

<import resource="b_1applicationContext.xml"></import>

在其他的配置文件中导入其他文件的配置。

 

Spring属性注入及方式：

 

方式一：Set方法注入（最重要）

    <bean name="car" class="com.huadian.c_injection.Car">
        <property name="name" value="公交车"></property>
    </bean>
<bean name="user" class="com.huadian.c_injection.User">
    <property name="name" value="lw"></property>
    <property name="car" ref="car"></property>
</bean>

使用property 标签。

需要注意的是，值类型用value，对象类型用 ref。

方式二：构造函数注入

<bean name="user" class="com.huadian.c_injection.User">
    <!--<constructor-arg name="userId" value="1"></constructor-arg>-->
    <constructor-arg name="name" value="123"></constructor-arg>
    <constructor-arg name="car" ref="car"></constructor-arg>
</bean>
    <bean name="car" class="com.huadian.c_injection.Car">
        <property name="name" value="自行车"></property>
    </bean>

使用constructor-arg标签。

index可以设置构造函数属性的顺序，例：写两个构造函数，

    public User(String name, Car car) {
        System.out.println("String name, Car car");
        this.name = name;
        this.car = car;
    }
    public User(Car car ,String name) {
        System.out.println("Car car ,String name");
        this.name = name;
        this.car = car;
    }
<constructor-arg name="name" value="123" index="0"></constructor-arg>

可以看到调用了不同的函数。

方式三：p名称空间注入

需要先添加约束

       xmlns:p="http://www.springframework.org/schema/p"
<bean name="user" class="com.huadian.c_injection.User"
        p:name="huadian"
        p:car-ref="car"></bean>
    <bean name="car" class="com.huadian.c_injection.Car">
        <property name="name" value="拖拉机"></property>
    </bean>

方式四：spel注入（类似OGNL）

    <!--spel注入方式-->
    <bean name="user2" class="com.huadian.c_injection.User">
        <property name="name" value="#{user.name}"></property>
        <!--<property name="car" ref="car.name"></property>-->
    </bean>

 

复杂类型注入方式（数组，List，Map，Properties）

 

public class User {
    private Integer userId;
    private String  name;
    private String  password;
    private Car car;
    private String[] array;
    private List list;
    private Map map;
    private Properties prop;
<property name="array">
        <array>
            <value>黄色</value>
            <value>绿色</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>喜羊羊</value>
            <value>语言</value>
            <ref bean="car"></ref>
        </list>
    </property>
    <property name="map">
        <map>
            <entry key="name" value="老哥"></entry>
            <entry key="age" value="18"></entry>
        </map>
    </property>
    <property name="prop">
        <props>
            <prop key="addr">车管所</prop>
            <prop key="higet">2</prop>
        </props>
    </property>

使用注解配置Spring

开启使用注解代理配置

<context:component-scan base-package="com.huadian.d_annotion"></context:component-scan>

将对象注册到容器中

@Componet,@Service（service层）,@Controller（web层）,@Repository(dao层实体层)

//@Component("user")
@Repository("user")//dao层，实体层
//@Service("user")
//@Scope("prototype")
//@Scope("singleton")

修改Scope

@Scope（“singleton|prototype|request|session”）

属性注入

方式一：通过反射的field赋值，破坏了封装性

方式二：通过set方法赋值，推荐使用

引用类型

@Autowired

会自动装配。原理是查找不同类型的对象。

@Autowired+@Qualifier

当出现多个相同类型不同名称的对象时，@Autowired无法找到具体哪一个，这时候需要使用@Qualifier，通过使用@Qualifier注解来告诉spring是哪一个对象

@Resource

@Resource（name=“car2”）手动指定哪一个对象。

Spring整合Junit测试

在测试类中添加注解：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:e_applicationContext.xml")
public class Demo {
    @Autowired
    private User user;

    @Test
    public void fun(){
        System.out.println(user);
    }
}

Spring AOP思想

可以解决中文乱码、跨域的解决、事务，用户未登入不能访问个人中心等页面的问题。

Spring实现AOP的原理

（1）动态代理（优先）：被代理的对象必须要实现接口，才能实现产生代理对象，如果没有接口将不能实现动态代理实现。

（2）cglib代理（没有接口）：第三方代理技术，cglib代理可以对任何类生产代理，代理的原理是对目标对象进行继承，如果目标对象被final修饰将无法被cglib代理。

 

AOP专业术语

增强（Advice）

添加一些特殊的功能我们添加的功能也就是增强
　比如：添加日志、管理事务。

切点（Pointcut）

需要增强的位置。

连接点(Joinpoint)

连接点就是程序执行的某个特定的位置，如：类开始初始化前、类初始化后、类的某个方法调用前、类的某个方法调用后、方法抛出异常后等。Spring 只支持类的方法前、后、抛出异常后的连接点。

切面(Aspect)

切面由切点和增强(或引介)组成，或者只由增强（或引介）实现

目标对象（Target）

被代理（增强）的对象

AOP代理(AOP proxy)

一个类被AOP织入后生成出了一个结果类

织入(Weaving)

织入就是将增强添加到目标类具体连接点上的过程。

 

例：结构

userservice

public interface UserService {
    public void add();
    public void del();
    public void modify();
}

userserviceimpl

public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("add");
    }

    @Override
    public void del() {
        System.out.println("del");
    }

    @Override
    public void modify() {
        System.out.println("modify");
    }
}

myadvice类

public class MyAdvice {
    public void before(){
        System.out.println("这是前置通知");
    }
    public void after(){
        System.out.println("这是后置通知");
    }
}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
							http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
							http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
							http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">

<bean name="UserService" class="com.huadian.h_spring_aop.service.impl.UserServiceImpl"></bean>
    <bean name="MyAdvice" class="com.huadian.h_spring_aop.MyAdvice"></bean>
    <aop:config>
        <aop:pointcut id="pc" expression="execution(* com.huadian.h_spring_aop.service.impl.*ServiceImpl.*(..))"></aop:pointcut>
        <aop:aspect ref="MyAdvice">
            <aop:before method="before" pointcut-ref="pc"></aop:before>
            <aop:after method="after" pointcut-ref="pc"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

测试类demo：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:h_applicationContext.xml")
public class Demo {
    @Autowired
    private UserService userService;

    @Test
    public void fun(){
        userService.add();
    }
}

结果

 

乔尼娜沙德星
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
maven-compiler-plugin:3.1:compile (default-compile)
为了低调的博客
05-22 1508
可能是由于IDEA的maven-compiler-plugin的<source>8</source> <target>8</target>版本不同所造成的这种报错 看看你的SDK什么版本如果是1.8 就改成8就好了 我也是遇见的这种问题自己想着办法改一下就好了！！！加油年轻热！！为了生活拼搏吧。 ...
idea 打包不出现target的原因
weixin_50656879的博客
05-30 3011
idea打包maven代码块 <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <conf
maven项目修改jdk版本
sunxuegang111的博客
11-28 287
1、在pom.xml文件中，添加 &lt;properties&gt;         &lt;maven.compiler.target&gt;1.8&lt;/maven.compiler.target&gt;         &lt;maven.compiler.source&gt;1.8&lt;/maven.compiler.source&gt;     &lt;/properties&g...
ant_<target>标签含义与使用
dayo9317的博客
08-24 729
<target>标记目标 目标是一个或多个任务的集合，任务是一段可执行的代码；构建文件中包含一个项目，在项目内部声明了所有目标； <target name = "run"> ... </target> 目标可以依赖其他目标， 并且被依赖的目标必需在当前目标之前执行。例如，有两个目标：一个编译目标，一个运行代码目标。现在，只能...
maven_如何修复无效的目标版本：Maven Build中的1.7、1.8、1.9或1.10错误
cunfu5234的博客
01-03 527
maven 如果您正在使用Maven构建Java项目，则可能是在Eclipse中运行mvn install或在命令提示符下运行mvn install，而构建失败并显示诸如“无效目标版本：1.7”或“无效目标版本：1.8”之类的错误，那么您来了到正确的地方。 在本文中，我将向您显示发生此错误的原因，以及即使在您的计算机上安装了更高的Java版本(如Java 9、10)，也可能在接下来的一个月中使用...
spring入门
12-23
让我们从这个"spring入门"的描述出发，深入探讨Spring的核心概念和技术。 1. **依赖注入（Dependency Injection，DI）**：Spring 的核心特性之一是依赖注入，它允许开发者在运行时将对象之间的依赖关系进行管理。...
Spring入门例子
04-14
Spring入门例子，只是实现了如何注入依赖，具体细节可以查看博客https://blog.csdn.net/qq_29924227/article/details/79942724
Spring入门经典
05-08
Beginning.Spring-Spring入门经典.pdf 学习 Spring 很好的入门书
超级详细的Maven使用教程
热门推荐
进修的CODER
08-13 23万+
什么是Maven？ 如今我们构建一个项目需要用到很多第三方的类库，如写一个使用Spring的Web项目就需要引入大量的jar包。一个项目Jar包的数量之多往往让我们瞠目结舌，并且Jar包之间的关系错综复杂，一个Jar包往往又会引用其他Jar包，缺少任何一个Jar包都会导致项目编译失败。 以往开发项目时，程序员往往需要花较多的精力在引用Jar包搭建项目环境上，而这一项工作尤为艰难，少一个Jar包...
Spring框架的基本原理分析
kingyxfly的博客
04-05 2万+
引言 工作有一段时间了，工作中基本每个项目都用到了Spring框架，说实话，很多人应该和我一样，只是“使用”了这个框架，对于框架的基本原理应该没怎么研究过。前段时间，和同事交流时，提到了Spring核心组件：IOC(控制反转)、AOP(面向切面编程)。交流的时候，只能大概说说，并不能完整讲出来。回来后，找相关文章和源码研究了下，特此记录。 Spring框架概念 Spring是一个开源的容...
spring框架之ioc简介
浔者的博客
10-29 291
spring框架 用途 整合其他框架，让他们协同工作 提供了声明式的事务管理 – 通过配置(xml, 注解)来管理事务 两大核心思想：IOC，AOP 1. IOC简介（控制反转） 在web项目，一个servlet class servlet extends HttpServlet{ init() service() destroy() } 创建不是程序员来管的 --&amp;amp;amp;amp;amp;amp;gt; tomcat容器...
Spring 框架学习5 - Spring 中的常用注解
qq_41302594的博客
09-19 262
文章目录Spring 中的常用注解1. 常用 IOC 注解的分类2.用于创建的 Component 注解2.1 Componet 注解的详解2.2 使用实例3. Controller、Service、Repository3.1 一个小小的例子4. 自动按照类型注入4.1 唯一对象类型匹配的注入4.2 多个对象类型匹配的注入5. 用于注入数据的注解：5.1 Qualifier5.2 Resource...
使用注解配置spring
weixin_42754908的博客
01-19 102
步骤： 导包4+2+spring-aop 1.为主配置文件引入新的命名空间（约束） 2.开始使用注解代理配置文件 3.在类中使用注解完成配置 把对象注册到容器 修改对象的作用范围 值类型注入 通过反射的Field赋值，破坏了封装性 通过set方法赋值，推荐使用 引入方式注入 初始化|销毁方法 ...
Spring属性注入（创建对象的时候给类里面的属性赋值）
qq_18119793的博客
08-02 3996
java代码中设置属性的三种方式 第一种set方法 public void setUsername(String username) { this.username = username; } User  user = new User(); user.setUsername(“lhj”); 第二种  有参构造实现属性注入  public User(String username)...
Spring框架相关知识
weixin_41804367的博客
05-26 129
程序的耦合与解耦 * 程序的耦合 * 耦合：程序间的依赖关系 * 包括： * 类之间的依赖 * 方法间的依赖 * 解耦： * 降低程序间的依赖关系 * 实际开发中： * 应该做到：编译期不依赖，运行时才依赖。 * 解耦的思路： *...
4种方法让SpringMVC接收多个对象
一个情绪猿的脖克...
07-10 17万+
问题背景： 我要在一个表单里同时一次性提交多名乘客的个人信息到SpringMVC，前端HTML和SpringMVC Controller里该如何处理？ 第1种方法：表单提交，以字段数组接收； 第2种方法：表单提交，以BeanListModel接收； 第3种方法：将Json对象序列化成Json字符串提交，以List接收； 第4种方法：将表单对象序列化成Json字符串提交，以List接收； 第4种方
Spring IOC-2
萝卜&青菜的博客
07-27 153
上一篇文章我们介绍了Spring的IOC，即控制反转，Spring来创建对象，程序中需要使用对象时，直接通过Spring容器来获取对象，并通过DI完成对象之间的注入关系。今天我们继续来学习IOC的相关知识。 1.Spring中的bean是根据scope来生成的，表示bean的作用域。 scope有4种类型： 1.singleton：单例，表示通过Spring容器获取的该对象是唯一的。 2....
Spring入门：简化企业应用开发的利器
Spring入门指南深入解析 Spring框架是由Rod Johnson创建的开源软件，旨在应对企业级应用程序开发中的复杂性。它采用JavaBean作为核心机制，实现了以往EJB（Enterprise JavaBeans）才能处理的任务，但其适用范围远超...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值