Spring基础

一、Spring概念

什么是Spring

Spring中文翻译为“春天”，他可以用来指代“SpringFramework”这个项目本身。随着时间的流逝，其他Spring项目已经在“SpringFramework”的基础上进行构建。所以，当我们说“Spring”的时候，实际上代表的是整个Spring项目系列。

为什么要用Spring框架

Spring框架是一款是轻量级的、开源的 JavaEE 一站式框架，它是为了解决企业应用开发的复杂性而创建的。

Spring框架总共大约有20个模块组成 

依赖注入

所谓依赖注入，就是由“IOC容器”在运行期间，动态地将某种依赖关系注入到对象之中。所以，依赖注入(DI)和控制反转(IOC)是从不同的角度的描述的同一件事情，就是指通过引入IOC容器，利用依赖关系注入的方式，实现对象之间的解耦。

 Spring IOC容器

Spring框架实现了“IOC容器”，org.springframework.context.ApplicationContext接口代表Spring IOC容器，并负责实例化、配置和组装Bean。Spring IOC容器通过读取配置信息获取有关要实例化、配置和组装哪些对象的指令，通过这些配置指令，它使您能够表达组成应用程序的对象以及这些对象之间的依赖关系。

IOC容器的原理

IOC入门案例

1、创建项目，导入spring的jar包

 2.按照如下目录结构创建接口及其实现类，做好准备工作

 servlet层

public class BookServlet {
BookService bookService;
@Test
public void add() {
System.out.println("BookServlet...add");
bookService.save();
}
}

service层

//接口
public interface BookService {
void save();
}
//实现类
public class BookServiceImpl implements BookService {
private BookDao bookDao;
@Override
public void save() {
System.out.println("BookServiceImpl...save");
bookDao.insert();
}
}

dao层

//接口
public interface BookDao {
public void insert();
}
//实现类
public class BookDaoImpl implements BookDao {
@Override
public void insert() {
System.out.println("BookDaoImpl...save");
}
}

3.使用spring完成IOC的配置和DI依赖注入

3.1创建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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--把所有对象创建到spring的IOC容器中，并起上名字
id：表示给对象起名字
class：类的全类名
-->
<bean id="bookDao" class="com.chen.dao.impl.BookDaoImpl"></bean>
<bean id="bookService" class="com.chen.service.impl.BookServiceImpl">
<!--spring的依赖注入：property表示BookServiceImpl的属性，常规属性使用value赋值，
类型属性使用ref引用-->
<property name="name" value="张三"/>
<property name="bookDao" ref="bookDao"/>
</bean>
</beans>

bean标签表示把对应class的对象创建到IOC容器中，如果当前对象有依赖的其他对象，那么可以 通过property对依赖的对象使用ref引用容器中已经注册过的对象。

注意：BookServiceImpl需要给bookDao属性设置setter方法，框架才能自动注入

public class BookServiceImpl implements BookService {
private BookDao bookDao;
public void setBookDao(BookDao bookDao) {
this.bookDao = bookDao;
}
@Override
public void save() {
System.out.println("BookServiceImpl...save");
bookDao.insert();
}
}

3.2在servlet中进行测试

• 首先获取IOC的容器；
• 从容器中获取bookService对象；
• 执行方法：servlet执行---service执行，由于spring完成了依赖注入------dao层执行

public class BookServlet {
BookService bookService;
@Test
public void add() {
System.out.println("BookServlet...add");
//1.获得IOC容器
ClassPathXmlApplicationContext context=new
ClassPathXmlApplicationContext("spring.xml");
//2.根据名字从容器中获取对象
bookService= (BookService) context.getBean("bookService");
bookService.save();
}
}

Spring的注解

@Component、@Service、@Controller、@Repository

这几个注解放在一起是因为功能基本一样的，都是将类注入到spring容器中，只不过它们使用的场景不同，被@Component,@Service,@Controller,@Repository注解标注的类，这些类会被纳入进spring容器中管理。

 @AutoWired、@Qualifier、@Resource

这3个注解都是基于注解方式进行自动装配，在容器里面将查找到的bean返回

• @AutoWired用得最多
• @Qualifier则需要配合@AutoWired使用@
• Resource则是可以通过名字进行自动装配

 

二、反射

2.1什么是反射

• Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。
• Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

2.2反射的原理

2.3反射的优缺点：
优点：

在运行时获得类的各种内容，进行反编译，对于Java这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。

缺点：

• 反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射；
• 反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。

2.4获取Class类对象的三种方法

万物皆对象，包括 类 也有对象，称为 类对象。要想获取类的信息首先要获取 类。

2.5获取Class对象三种方法 

• 
  // 通过类的全限定类名(包名+类名)获取类
  Class clazz = Class.forName("类的全限定类名(包名+类名)");

• // 直接获取类
  Class clazz = Object.class;

• // 通过实例对象获取其类
  Class clazz = object.getClass()

  2.6反射的基本使用操作：

Java语言允许通过程序化的方式间接对Class的对象实例操作，Class文件由类装载器装载后，在JVM中将形成一份描述Class结构的元信息对象，通过该元信息对象可以获知Class的结构信息：构造函数、属性和方法等。Java允许用户借由这个Class相关的元信息对象间接调用Class对象的功能

1.在Idea中导入jar包

2.在src中创建——service包并在service中创建一个接口

package com.service;
 
public interface BookService {
void save();
}

 3.在service中创建一个impl包并创建两个类

BookServiceImpl类:

package com.service.impl;
 
import com.service.BookService;
 
public class BookServicelmpl implements BookService {
 
 
    @Override
    public void save() {
        System.out.println("BookServicelmpl...save");
    }
}

BookServiceVip：

package com.service.impl;
 
import com.service.BookService;
 
/**
 * 高配版
 */
public class BookServiceVip implements BookService {
    //属性
    public String name;
    protected String sex;
    int age;
    private String address;
 
    //构造方法
    public BookServiceVip() {
    }
 
    public BookServiceVip(String name) {
        this.name = name;
    }
 
    public BookServiceVip(String name, int age, String sex, String address) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.address = address;
    }
 
    @Override
    public void save() {
        System.out.println("BookServiceVip...save");
    }
}
 

4.在src中创建一个servlet包，并在servlet包中创建BookServlet测试类

package com.zhao.servlet;
 
import com.service.BookService;
import com.service.impl.BookServiceVip;
import com.service.impl.BookServicelmpl;
import org.junit.Test;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
 
public class BookServlet {
    BookService bookService1 = new BookServicelmpl();
    BookService bookService2 = new BookServiceVip();
 
    BookServicelmpl b1 = new BookServicelmpl();
    BookServiceVip b2 = new BookServiceVip();
 
    @Test
    public void save() throws ClassNotFoundException {
        System.out.println("BookServlet...save");
        bookService1.save();
 
        //根据类的全类名通过Class获得类的Class加载器
        Class cla = Class.forName("com.zhao.service.impl.BookServiceVip");
        //类的加载器可以获得类中的东西--属性（存储数据）、构造方法（创建对象）、功能方法（完成功能）
        //1.获取类中的属性
        Field[] fields = cla.getFields();//只有获取共有的属性
        for (Field field : fields) {
            System.out.println(field);
        }
 
        System.out.println("--------------");
        Field[] fields1 = cla.getDeclaredFields();//可以获取任意修饰符修饰的属性
        for (Field field : fields1) {
            System.out.println(field);
        }
 
        System.out.println("--------");
        //2.获取类中的构造方法
        Constructor[] constructors = cla.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
 
        System.out.println("--------------");
 
        Constructor[] constructors1 = cla.getDeclaredConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println(constructor);
        }
    }
}

5.创建一个Info.properties配置文件

key=value
className=com.zhao.service.impl.BookServiceVip

6.test02测试类 

package com.servlet;
 
import com.service.BookService;
import org.junit.Test;
 
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.util.Properties;
 
public class Test02 {
 
    @Test
    public void test() throws Exception {
        //读取配置文件
        //1.通过文件位置获得输入流
//        File file=new File("D:\\2103\\spring\\spring01\\src\\info.properties");
//        InputStream stream=new FileInputStream(file);
        //在类的根路径src加载器配置文件
        InputStream stream = Test02.class.getClassLoader().getResourceAsStream("info.properties");
        //使用Properties加载输入流
        Properties properties = new Properties();
        properties.load(stream);
        //获取配置文件中key值对应的value
        String value = properties.getProperty("key");
        String className = properties.getProperty("className");
 
        //根据类的全类名通过Class获得类的Class加载器
        Class cla = Class.forName(className);
        //获取类的无参构造器
        Constructor constructor = cla.getConstructor();
        //使用构造器创建对象
        BookService bookService = (BookService) constructor.newInstance();
        //执行对象的方法
        bookService.save();
    }
 
}