java框架----spring

前言

想要学好spring，必须时时刻刻想着，spring的本质就是一个容器，放java对象的容器，java对象在spring容器中也叫做bean对象。

1、什么是框架？

框架是一种基于某种编程语言或平台的软件设计模式，它提供了一个可复用的解决方案。框架通常包含了一些模板代码和库文件，这些代码和文件可以被程序员用来快速地进行开发，以便其专注于应用本身而不必关注底层技术细节。

框架通常包含了某种标准的架构，以及一套约定俗成的代码组织规则，这些规则可以使得在框架的帮助下，开发者能够更加容易地协作开发，同时也能够提高代码的可读性和可维护性。常见的框架有Web框架、游戏引擎框架、移动应用框架等。

2、框架的作用

1、提供标准化的编程模式和规范，使开发人员能够快速构建出代码结构，减少代码冗余和错误。

2、提供一系列可重用的组件和库，开发者可以根据实际需求进行选择和组合，降低代码复杂度和维护成本。

3、提供安全性和可靠性，框架通常包含一些常见的安全措施和错误处理机制，可以帮助开发人员减少安全漏洞和错误。

4、提高开发效率和速度，框架一般掌握了一些设计模式和最佳实践，基于框架进行软件开发能够提高开发效率和速度。

5、降低开发成本和风险，框架具有高度的标准化和重用性，能够减少开发成本和风险。

3、Spring是什么？

Spring是一个开源的Java应用程序框架。
Spring框架提供了一系列的工具和框架，用于开发Java企业级应用。
这些工具和框架包括依赖注入、面向切面编程、数据库访问、事务管理、Web开发等。

Spring是分层的JavaSE/EE应用full-stack （一站式） 轻量级 开源的（免费） 半成品（实现部分功能，不能实现全部功能）框架，以 IOC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

分层： 视图层，逻辑层，持久层

full-stack：基本就是用spring能解决开发里面的任何需要，一站式服务 ，开发里面的所有组件都能提供

轻量级：对比重量级，EJB

Spring的体系结构

1. 核心容器（Core Container）：包括IoC（Inversion of Control）和DI（Dependency
   Injection）模块，支持对象的生命周期管理和依赖注入，实现了面向对象编程的基本原则，如开闭原则和依赖倒置原则。
   2、 数据访问/集成（Data Access/Integration）：提供对数据源的访问和集成，包括JDBC（Java Database Connectivity）、ORM（Object-Relational Mapping）框架、事务管理等。
   3、 Web（Web）：提供Web应用开发的支持，包括MVC（Model-View-Controller）框架、REST（Representational
   State Transfer）支持、WebSocket、Servlet等。
   4、 AOP（Aspect-Oriented Programming）：提供面向切面编程的支持，包括声明式事务、日志记录、性能监控等。
   5、 测试（Testing）：提供单元测试和集成测试的支持，包括测试框架、mock对象等。
   6、 安全（Security）：提供认证和授权的支持，包括基于角色的访问控制、加密解密等。
   Spring体系结构的设计思想是基于模块化、松耦合、可扩展、可重用和可测试等原则，可以根据应用的需求选择相应的模块进行集成，从而实现高效、稳定、灵活的应用开发。

6 Spring优势

- 方便解耦，简化开发（依赖注入和IOC）

- 方便集成各种优秀框架（支持框架整合，留有其他框架的兼容接口）

- 方便程序的测试(test底层支持)

- 切面编程的支持（AOP）

- 声明式事务的支持@Transactional（注解和事务）

- 降低JavaEE API的使用难度（轻松上手，简单操作

IOC 反转控制

IOC 概念（spring作为容器，谁来放谁来拿）

• IoC 全称为 Inversion of Control，翻译为 “控制反转”，它还有一个别名为 DI（ Dependency Injection）,即依赖注入。本质的功能就是：就是由 Spring IOC 容器来负责对象的生命周期和对象之间的关系
  -== 想要学好spring，必须时时刻刻想着，spring的本质就是一个容器，放java对象的容器，java对象在spring容器中也叫做bean对象。==

案例

 1 导入 Spring 开发的基本包坐标
- 2 编写 Dao 接口和实现类
- 3 创建 Spring 核心配置文件
- 4 在 Spring 配置文件中配置 UserDaoImpl
- 5 使用 Spring 的 API 获得 Bean 实例

1 导入 Spring 开发的基本包坐标

<!--导入spring的context坐标，context依赖core、beans、expression-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.5.RELEASE</version>
    </dependency>

2 编写 Dao 接口和实现类

public interface IUserDao {
    void say();
}


public class UserDaompl implements IUserDao {
    public void say() {
        System.out.println("你好");
    }
}

3 创建 Spring 核心配置文件

4 在 Spring 配置文件中配置 UserDaoImpl

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <bean id="user" class="com.xinzhi.service.impl.UserDaompl" />

</beans>

5 使用 Spring 的 API 获得 Bean 实例

public static void main( String[] args ) {
   ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
   UserDaompl bean = context.getBean(UserDaompl.class);
       bean.say();
}

4 Bean标签说明

• id：Bean实例在Spring容器中的唯一标识
• class：Bean的全限定名称
• scope: 范围配置，spring默认是单例模式。

5 生命周期

1）当scope的取值为singleton时（系统默认的）
      Bean的实例化个数：1个
      Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
      Bean的生命周期：
						对象创建：当应用加载，创建容器时，对象就被创建了
						对象运行：只要容器在，对象一直活着
						对象销毁：当应用卸载，销毁容器时，对象就被销毁了
2）当scope的取值为prototype时
      Bean的实例化个数：多个
      Bean的实例化时机：当调用getBean()方法时实例化Bean
					  对象创建：当使用对象时，创建新的对象实例
					  对象运行：只要对象在使用中，就一直活着
					  对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了 （ jvm gc垃圾回收）

注意： 以上bean对象实例化都是spring调用对象的无参构造方法。（还有两种方法，开发中没见使用过：工厂实例方法，工厂静态方法）

DI 依赖注入

两种方式 set注入 构造注入

想要理解依赖注入，需要将这个概念拆分两部分理解，依赖和注入。

依赖： 两个对象之间的关系，比如service想要调用dao的方法，那么service里就需要dao对象，这就是依赖。

注入：就是将dao给了service的过程，在spring的容器中，注入是容器给完成的。也就是小伙子的对象不是自己找的，谁给的？ dao是谁给service的？

• 故名思意，必须有set方法，注意注入的方式是set方式，但是主动执行的人是spring容器

• 新建IUserService结合和UserServiceImpl

public interface IUserService {
    void save();
}

public class UserServiceImpl implements IUserService {
    private IUserDao userDao;

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

    public void save() {
        userDao.say();
    }
}

 <bean id="user" class="com.xinzhi.dao.impl.UserDaompl" />
    
    <bean id="userService" class="com.xinzhi.service.impl.UserServiceImpl">
        <property name="userDao" ref="user"/>
	</bean>

 public static void main( String[] args ) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        UserServiceImpl bean = context.getBean(UserServiceImpl.class);
        bean.save();
    }

注解开发

开发步骤

1 扫描包下的组件（注解）

​ <context:component-scan base-package=“com.xinzhi”/>

2 添加注解

@Component("user")
public class User {
    @Value("1")
    private int id;
    @Value("张作榕")
    private String username;
    @Value("20")
    private int age;
    //set get 方法
}


/**
 *dao层注解
 */
@Repository("userDao")
public class UserDaompl implements IUserDao {

    @Autowired
    private User user;

    public void say() {
        System.out.println(user);
        System.out.println("UserDao save method running....");
    }
}

/**
 * service注解
 */
@Service("userService")
public class UserServiceImpl implements IUserService {
//    @Autowired
//    @Qualifier("userDao")
    @Resource(name = "userDao")
    private IUserDao userDao;

    public void save() {
        userDao.say();
    }
}

 public static void main( String[] args ) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        UserServiceImpl bean = context.getBean(UserServiceImpl.class);
        bean.save();
    }

注意： 一般用autowired注解，因为spring默认都是单例模式，所以也很少和Qualifier配合使用。Resource如果注入的对象不存在会抛出异常