引言:以下记录一些自己在使用时pringle框架时的一些自己心得合成体会时,如有侵权,请联系本博主。

1. spring基本都使用

spring是一个开源的轻量级框架,其目的是用于简化企业级应用程序开发,降低侵入性;

spring提供的IOC和AOP功能,可以将组件的耦合度降至最低,便于系统日后的维护和升级。

在spring中,任何的java类和JavaBean都被当成Bean处理,这些Bean通过容器管理和使用。

1.1 最基本的spring的使用

spring容器有BeanFactory和ApplicationContext两种类型,ApplicationContext接口继承自BeanFactory接口,拥有更多的

企业级方法,推荐使用该类型。 ClassPathXmlApplicationContext是ApplicationContext的一个实现类。

(1) spring容器实例化:创建spring的IOC容器对象

@Test
//测试使用无参构造器创建对象
public void test1(){
//启动spring容器
ApplicationContext ac=new ClassPathXmlApplicationContext("config/basic.xml");
//调用容器的方法来获取对象
//方法的返回值类型是object,所以要强转,或者调用重载的方法(多传一个参数),
//反射,这是一个class对象,告诉它返回类型.
ExampleBean eb=ac.getBean("eb",ExampleBean.class);
System.out.println(eb);
}

说明:参数值config/basic.xml是spring配置文件的位置

(2) bean的实例化:在创建spring的IOC容器对象的时候,它会调用basic.xml中配置的bean(HelloWorld)的构造器进行初始化,

同时会调用属性的set方法对属性进行赋值();

<!-- 使用无参构造器创建对象 :告诉容器你要创建哪个对象-->
<!-- id 属性:bean的名称,要求唯一。
class属性:bean的完整的类名(要求包含包名)。 --> <bean id="eb" class="basic.ExampleBean"/> <!-- 这里写的是包含ExampleBean类的那个包名 -->

java类ExampleBean如下:

package basic;

public class ExampleBean {

    public ExampleBean() {
System.out.println("ExampleBean's 无参构造"); } }

除了使用构造器来实例化对象(主要方式),还可以使用以下两种方式来实例化对象(了解):

<!-- 使用静态工厂的方法创建对象 -->
<!-- factory-method属性:指定一个静态方法
注:spring容器会调用指定静态方法来创建对象 -->
<bean id="cal" class="java.util.Calendar" factory-method="getInstance"/> <!-- 使用实例工厂方法创建对象 -->
<!-- factory-bean属性:某个bean的id。
factory-method属性:指定一个实例方法。 -->
<bean id="date1" factory-bean="cal" factory-method="getTime"/>

1.2 bean的作用域、生命周期以及延迟实例化

<!-- 配置作用域 -->
<!-- scope属性:默认值是singleton(单例,即容器针对一个bean的配置,只会创建一个实例)。
如果值是prototype(原型,会创建多个实例)-->
<bean id="stu1" class="basic.Student" scope="prototype"/> <!-- 配置生命周期相关的两个方法 -->
<!-- init-method属性:初始化方法名
destroy-method属性:销毁方法的名称,只有作用域为单例的bean,销毁方法才会执行-->
<bean id="mb1" class="basic.MessageBean" init-method="init"
destroy-method="destroy" /><!-- 告诉容器要销毁哪个方法 --> <!-- 配置延迟加载 -->
<!-- 默认情况下,当spring容器启动之后,会将所有作用域为当例(singleton)先创建好 -->
<bean id="lz1" class="basic.LazyBean" lazy-init="true"/> <!-- 将以上几种配置合成 -->
<bean id="mb2" class="basic.MessageBean1" init-method="init"
destroy-method="destroy" scope="singleton" lazy-init="false"/>
@Test
public void test1(){
ApplicationContext ac=new ClassPathXmlApplicationContext("config/basic2.xml");
Student stu1=ac.getBean("stu1",Student.class);
Student stu2=ac.getBean("stu1",Student.class);
//默认情况下,对于一个bean的配置,容器只会创建一个对象(即作用域为singleton).
System.out.println(stu1==stu2);
} @Test
//测试生命周期
public void test2(){
//启动spring容器
//ApplicationContext这个接口没有定义关闭容器的方法,所以需要用其子接口。
//AbstractApplicationContext这是ApplicationContext子接口,里面有关闭的方法。
AbstractApplicationContext ac=new ClassPathXmlApplicationContext("config/basic2.xml");
//通过容器获得对象
MessageBean mb1=ac.getBean("mb1",MessageBean.class);
//调用对象的方 法
mb1.sendMsg();
//首先要先关闭容器,才销毁
ac.close();
} @Test
//测试 延迟加载
public void test3(){
ApplicationContext ac=new ClassPathXmlApplicationContext("config/basic2.xml");
// 默认情况下,当spring容器启动之后,会将所有作用域为当例(singleton)先创建好
} @Test
//多种配置合成在一起
public void test4(){
AbstractApplicationContext ac=new ClassPathXmlApplicationContext("config/basic2.xml");
MessageBean1 mb2=ac.getBean("mb2",MessageBean1.class);
mb2.sendMsg();
ac.close();
}
package basic;

public class Student {

    public Student() {
System.out.println("Student 无参构造");
} } public class LazyBean {
public LazyBean() {
System.out.println("实例化:LazyBean()");
}
} public class MessageBean { public MessageBean() {
System.out.println("实例化:MessageBean()");
} public void init(){
System.out.println("初始化:init()");//表示获取一些资源
} public void sendMsg(){
System.out.println("调用方法:sendMsg()");
} public void destroy(){
System.out.println("销毁:destroy()");
}
}
public class MessageBean1 { public MessageBean1() {
System.out.println("实例化:MessageBean1()");
}
public void init(){
System.out.println("初始化:init()");
}
public void sendMsg(){
System.out.println("调用方法:sendMsg()");
}
public void destroy(){
System.out.println("销毁方法:destroy()");
}
}

2. IOC (Inversion of Control,控制反转)

IOC是指程序中对象的获取方式发生了反转,由最初的new方式创建,转变为由第三方框架(spring)创建,

注入(DI),它降低了对象之间的耦合度。spring容器是采用了DI方式实现方法了IOC空字符串,IOC是spring框架的基础和核心。

2.1 DI

DI:依赖注入(Dependency Injection)的基本原理就是将一起工作具有关系运算符的对象添加,通过

构造方法参数或方法参数传入建立关联,因此容器的工作就是创建bean时注入那些依赖关系。

IOC是一种思想,而DI是实现IOC的主要技术途径。

DI主要有两种注入方式:Setter注入和构造器注入。

(1) Setter注入

通过调用无参构造器或无参static工厂方法实例化bean以后,调用该bean的setter()方法,即可实现setter方式的注入.

property属性表示采用set方式注入,既然是注入,那肯定是发生在两个组件(对象)之间。

方法一:直接注入值(value)

<bean id="computer" class="com.bean.Computer">
<property name="mainboard" value="技嘉"/>
</bean>
public class Computer{
private String mainboard; // 主板
public String getMainboard(){
return mainboard;
}
public void setMainboard(String mainboard){
this.mainboard = mainboard;
}
}

方法二:引用的方式(ref),ref主要用户引用对象

<!-- 告诉spring采用无参构造器的方法创建对象B对象 -->
<bean id="b1" class="ioc.B"/>
<bean id="c1" class="ioc.C"/> <!-- 配置依赖注入(采用set方法) -->
<!-- property属性:表示采用set方法来注入。name属性用来指定属性名(首先首字母B大写,然后在前面加set),ref属性指定属性值 -->
<bean id="a1" class="ioc.A">
<!-- setB -->
<property name="service" ref="c1"></property>
</bean>

测试set方式注入:

@Test
//测试set方法注入
public void test5(){
AbstractApplicationContext ac=new ClassPathXmlApplicationContext("config/ioc.xml");
A a1=ac.getBean("a1",A.class);
a1.execute();
}
package ioc;

import ioc.Service;

public interface Service {
public void f1();
} public class B implements Service{
public B(){
System.out.println("B()");
}
public void f1(){
System.out.println("B's f1()");
}
} public class C implements Service{
public C(){
System.out.println("C()");
}
public void f1(){
System.out.println("C's f1()");
}
} public class A {
private Service service;
//容器调用对象提供的set方法来建立依赖关系
//1.类应该提供有对应的set方法
//2.在配置文件中,使用property元素来配置依赖关系 public void setService(Service service) {
System.out.println("setService()");
this.service = service;
} public A(){
System.out.println("A()");
} public void execute(){
service.f1();
}
}
//执行结果
B()
C()
A()
setService()
C's f1()

(2) 构造器注入(使用相对较少)

基于构造器的注入是通过调用带参数的构造器来实现,容器在bean被实例化的时候,根据参数类型执行相应的构造器。

构造器注入,可以强制给bean注入某些参数,比set注入更严格。

构造器的注入一般格式为:

方法一:直接注入值(value)

按构造参数索引指定注入

<bean id=''phone" class="com.bean.MobilePhone">
  <constructor-arg index="0"> value="ARM"/> //当然这里也可以采用ref去引用另外的bean,但是采用ref的时候主要用于引用对象
  <constructor-arg index="1"> value="2G"/>
</bean>
public class MobilePhone{
  private String cpu;
  private String ram;
  //构造方法
  public MobilePhone(String cpu,String ram){
    this.cpu = cpu;
    this.ram = ram;
  }
}

方法二:采用引用的方式(ref)

<!-- 配置依赖注入(采用构造器方式注入) -->
<!-- index属性:指定参数的位置(从0开始). -->
<bean id="wt1" class="ioc.Waiter" />
<bean id="rest1" class="ioc.Restaurant" >
<!-- 将ref传到构造方法的第一个参数上 -->
<constructor-arg index="0" ref="wt1"></constructor-arg>
</bean>
@Test
//测试构造器注入
public void test6(){
AbstractApplicationContext ac=new ClassPathXmlApplicationContext("config/ioc.xml");
Restaurant rest1=ac.getBean("rest1",Restaurant.class);
System.out.println(rest1);
}
 package ioc;

 import ioc.Waiter;

 public class Waiter {

     public Waiter() {
System.out.println("Waiter()");
} } public class Restaurant {
private Waiter wt; public Restaurant(){
System.out.println("Restaurant()");
}
public Restaurant(Waiter wt) {
System.out.println("Restaurant(wt)");
this.wt = wt;
} @Override
public String toString() {
return "Restaurant [wt=" + wt + "]";
} }
//执行结果
Waiter()
Restaurant(wt)
Restaurant [wt=ioc.Waiter@5f282abb]

 2.2 自动装配

<bean id="wt1" class="ioc.Waiter"/>
<!-- 自动装配 :默认情况下,容器禁止自动装配。-->
<!-- (1)byName:以属性名(wt)作为bean的id,查找配置文件,找到之后,会使用set方法来注入。
注: 找不到会注入null值, 不会找到多个符合条件的bean。
(2)byType:以属性类型(Waiter)作为bean的类型,查找配置文件(ioc.Waiter),找到之后,会使用set方法来注入。
注:找不到会注入null值,如果找到多个符合条件的bean,会出错。
(3)constructor:与byType类似,只不过会使用构造器来注入。 -->
<bean id="rest" class="ioc.Restaurant" autowire="byType"/>
@Test
//测试自动装配
public void test1(){
ApplicationContext ac=new ClassPathXmlApplicationContext("ioc.xml");
Restaurant rest=ac.getBean("rest",Restaurant.class );
System.out.println(rest);
}
 package ioc;

 public class Restaurant {
private Waiter wt;
public Restaurant(){
System.out.println("构造:Restaurant()");
} public void setWt(Waiter wt) {
System.out.println("setWt()");
this.wt = wt;
} @Override
public String toString() {
return "Restaurant [wt=" + wt + "]";
}
} public class Waiter {
public Waiter() {
System.out.println("构造:Waiter()");
}
}

1.spring基础知识讲解的更多相关文章

  1. Spring基础知识

    Spring基础知识 利用spring完成松耦合 接口 public interface IOutputGenerator { public void generateOutput(); } 实现类 ...

  2. Html基础知识讲解

    Html基础知识讲解 <title>淄博汉企</title> </head> <body bgcolor="#66FFCC" topmar ...

  3. python基础知识讲解——@classmethod和@staticmethod的作用

    python基础知识讲解——@classmethod和@staticmethod的作用 在类的成员函数中,可以添加@classmethod和@staticmethod修饰符,这两者有一定的差异,简单来 ...

  4. java Reflection(反射)基础知识讲解

    原文链接:小ben马的java Reflection(反射)基础知识讲解 1.获取Class对象的方式 1.1)使用 "Class#forName" public static C ...

  5. spring 基础知识复习

    spring是一个分层架构,由 7 个定义良好的模块组成.Spring 模块构建在核心容器之上,核心容器定义了创建.配置和管理 bean 的方式. 组成spring框架的每个模块(或组件)都可单独存在 ...

  6. Spring 基础知识

    Spring架构简单描述 原文:https://www.shiyanlou.com/courses/document/212 Spring 概述 1. Spring 是什么 Spring是一个开源的轻 ...

  7. ElasticSearch(四):关于es的一些基础知识讲解

    上一篇博客更新完之后,我发现一个问题:在我创建索引的时候依旧无法准确的理解每个字段的意义,所以就有了这个. 1. 关于索引 1.1 关于索引的一些基础知识 在创建标准化索引的时候,我们传入的请求体如下 ...

  8. shell基础知识讲解

    第1章 shell基础 1.1 什么叫做shell编程 shell编程也叫做bash高级编程语法 1.2 常见的shell命令解释器 bash            redhat和centos使用 d ...

  9. 2015年12月10日 spring初级知识讲解(三)Spring消息之activeMQ消息队列

    基础 JMS消息 一.下载ActiveMQ并安装 地址:http://activemq.apache.org/ 最新版本:5.13.0 下载完后解压缩到本地硬盘中,解压目录中activemq-core ...

随机推荐

  1. php打乱数组二维数组、多维数组

    //这个是针对二维数组的!下面针对多维数组的乱序方法<?php function shuffle_assoc($list) { if (!is_array($list)) return $lis ...

  2. Golang两种执行流程以及区别

    Go语言的执行方式有两种,一种是编译后再执行,另一种直接go run执行. 一.先编译后执行 .go文件(源代码)--->go build指令把源代码编译(如果是windows下会编译出一个.e ...

  3. Vue中的事件与常见的问题处理

    Vue的事件:获取事件对象$event: 事件冒泡:事件会向上传播 原生js阻止事件冒泡,需要先获取事件对象,再调用stopPropagation()方法: vue事件修饰符stop,例@clik.s ...

  4. P1297 [国家集训队]单选错位(期望)

    P1297 [国家集训队]单选错位 期望入门 我们考虑涂到第$i$道题时的情况 此时题$i$答案有$a[i]$种,我们可能涂$a[i+1]$种 分类讨论: 1.$a[i]>=a[i+1]$: 可 ...

  5. socket编程-阻塞和非阻塞

    转自:https://www.cnblogs.com/sunziying/p/6501045.html 建立连接 阻塞方式下,connect首先发送SYN请求道服务器,当客户端收到服务器返回的SYN的 ...

  6. python简说(十四)内置函数

    # sorted 排序# map  循环调用函数的,保存返回值# filter  循环调用函数,如果函数返回false,那么就过滤掉这个值,是指从你传入的这个list里面过虑. def abc(num ...

  7. 搭建ldap自助修改密码系统--Self Service Password

    系统版本:centos6 Self Service Password版本:1.1 服务安装: 安装依赖:yum install php70-ldap.x86_64 -y (版本尽量大于5.3,否则会提 ...

  8. linux下安装与部署redis

    一.Redis介绍 Redis是当前比较热门的NOSQL系统之一,它是一个key-value存储系统.和Memcache类似,但很大程度补偿了Memcache的不足,它支持存储的value类型相对更多 ...

  9. python引入模块

    1.自定义模块model_1.py def add(a,b): return a+b def dec(a,b): return a-b HEAD = "55AA" 2.程序代码 i ...

  10. Bootstrap3基础 glyphicon 设置图标的颜色与大小

      内容 参数   OS   Windows 10 x64   browser   Firefox 65.0.2   framework     Bootstrap 3.3.7   editor    ...