首页 > 软件编程 > java > Spring框架概述和翻转权限控制

Spring框架概述和翻转权限控制方式

2025-08-16 09:44:51 作者：LSL666_

Spring是Java企业级开发的核心框架,通过IOC和AOP解耦对象依赖,统一生命周期管理,支持分层注解（@Service/@Repository等）,覆盖中大型项目全场景,成为标准化生态基石

1.1 Spring框架概述和翻转权限控制

1.Spring框架是右边框架的父框架。

Spring 并非简单的 “父框架”，而是Java 生态中一站式企业级开发解决方案。它通过模块化设计（Core、Context、AOP、TX 等模块），为 Servlet 等框架提供底层支撑：

Servlet 专注于 “请求 - 响应” 流程，但架构复杂项目时（如分布式、高并发场景），需手动管理对象创建、依赖关系，开发效率低。
Spring 则通过 IOC（控制反转）、AOP（面向切面编程） 等核心机制，解决 “对象管理复杂”“功能扩展侵入性强” 等问题，覆盖从小型项目到中大型系统的全场景开发，而非局限于 “中大型项目”。

对比 Servlet 的核心优势

维度	Servlet 开发痛点	Spring 解决方案
对象管理	需手动 new 对象，依赖关系混乱	IOC 容器自动管理对象生命周期，依赖自动注入
功能扩展	修改核心代码实现扩展（如权限校验）	AOP 无侵入式增强，通过 “切面” 动态扩展功能
架构复杂度	应对中大型项目需大量重复编码（事务、日志）	模块化组件（@Service/@Repository 等）+ 生态整合（Spring Boot、Cloud ）

2.Spring的核心功能：

传统开发中，对象的创建（如 UserService userService = new UserService() ）由开发者手动控制；

Spring 则通过 “控制反转”，将对象创建、依赖装配的权力转移给框架。开发者只需定义 “需要什么对象”，由 Spring 自动完成 “创建 - 管理 - 注入” 全流程。

IOC是一个容器，Spring 启动时，会扫描配置（注解 / XML ），将标记的类（如 @Component/<bean> ）实例化为对象（Bean），并存储在 IOC 容器 中，每次需要时只用从IOC里面获取

核心价值：

解耦对象依赖：无需硬编码 new 操作，通过 @Autowired 即可获取容器中的 Bean。
统一生命周期管理：Bean 的创建、初始化、销毁由容器统一控制（如 init-method/@PostConstruct ）。

3.Spring对bean的管理

Bean 是 Spring 对 “受管对象” 的抽象，即由 IOC 容器创建、管理、注入的对象。它可以是：

业务逻辑类（@Service 标记的 UserService ）
数据访问类（@Repository 标记的 UserDAO ）
工具类（@Component 标记的 CommonUtils ）

Spring 提供分层语义注解，明确 Bean 的职责（替代通用 @Component ）：

注解	适用场景	设计意图
@Component	普通工具类 / 通用组件	基础标记，无明确业务分层含义
@Controller	表现层（Web 层）	处理 HTTP 请求，封装响应逻辑
@Service	业务层（Service 层）	实现业务规则、协调 DAO 与 Controller
@Repository	持久层（DAO 层）	封装数据库操作（MyBatis/ORM ）

注入属性指的是给属性赋值。

基于xml注入属性的方式有两种，一种是通过get/set方法，一种是通过构造器。

基于注解的方式注入属性需要用到的注解

@Value 用于注入普通类型（String，int，double等类型）
@Autowired 默认按类型进行自动装配（引用类型）
@Qualifier 不能单独使用必须和@Autowired一起使用，强制使用名称注入
@Resource Java提供的注解，也被支持。使用name属性，按名称注入

总结：Spring 为何是 Java 开发 “必修课”

生态基石：Spring 不仅是 “框架”，更是 Java 企业级开发的标准化生态（Spring Boot、Cloud、Security 等均基于其扩展）。
解耦与效率：通过 IOC 实现对象解耦，AOP 实现功能无侵入增强，大幅降低中大型项目的维护成本。
语义化与规范：分层注解（@Controller/@Service ）和注入机制，推动团队代码规范与架构清晰。

掌握 Spring 核心机制（IOC/Bean 管理），是迈向 Java 中大型项目开发的关键一步 —— 它让 “复杂系统开发” 从 “人力堆砌” 变为 “框架驱动”。

1.2 代码

1.2.1 创建项目

新建一个Maven项目

什么都不选，直接下一步

创建完成，然后在pom.xml中导入相关依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.qcby</groupId>
    <artifactId>Spring</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
</project>

1.2.2 创建对象

new创建对象和基于xml的方式创建对象

package com.qcby;

public class Demo {
    public void hello(){
        System.out.println("hello world");
    }
}

package com.qcby;

public class User {
    public void flay(){
        System.out.println("我会飞……");
    }
}

在resources文件里创建一个Spring.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- IOC管理对象的方式-->
    <!-- Spring基于xml的方式去创建对象-->
    <bean id="demo" class="com.qcby.Demo"/>
    <bean id="user" class="com.qcby.User"/>
</beans>

import com.config.SpringConfig;
import com.qcby.Cat;
import com.qcby.Demo;
import com.qcby.Dog;
import com.qcby.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    /**
     *  传统创建对象的方式
     *  人为手动创建，每次获取对象需要new对象
     */
    @org.junit.Test
    public void run(){
        Demo demo = new Demo();
        demo.hello();
    }

    /**
     * IOC
     * 启动Spring项目的时候，Spring创建的
     * 并且会将创建的对象放在一个IOC容器中，每次需要时只用从IOC里面获取
     */
    @org.junit.Test
    public void run1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Demo demo = (Demo)context.getBean("demo");
        demo.hello();
    }

    @org.junit.Test
    public void run2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        User user = (User)context.getBean("user");
        user.flay();
    }
}

基于注解的方式创建对象

Bean 名称的默认生成规则：

当使用@Component、@Service、@Repository、@Controller等注解时，Spring 会自动生成 Bean 名称。

规则：将类名首字母小写，例如类名UserService的默认 Bean 名称为userService。

对于下面代码使用的区别见后文。

package com.qcby;

import org.springframework.stereotype.Service;

@Service
public class Demo {
    public void hello(){
        System.out.println("hello world");
    }
}

package com.qcby;

import org.springframework.stereotype.Controller;

@Controller
public class User {
    public void flay(){
        System.out.println("我会飞……");
    }
}

package com.qcby;

import org.springframework.stereotype.Component;

@Component
public class Cat {
    public void run(){
        System.out.println("猫跑的很快……");
    }
}

package com.qcby;

import org.springframework.stereotype.Repository;

@Repository
public class Dog {
    public void jump(){
        System.out.println("狗跳的很高");
    }
}

import com.config.SpringConfig;
import com.qcby.Cat;
import com.qcby.Demo;
import com.qcby.Dog;
import com.qcby.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    /**
     *  传统创建对象的方式
     *  人为手动创建，每次获取对象需要new对象
     */
    @org.junit.Test
    public void run(){
        Demo demo = new Demo();
        demo.hello();
    }

    /**
     * IOC
     * 启动Spring项目的时候，Spring创建的
     * 并且会将创建的对象放在一个IOC容器中，每次需要时只用从IOC里面获取
     */
    @org.junit.Test
    public void run1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Demo demo = (Demo)context.getBean("demo");
        demo.hello();
    }

    @org.junit.Test
    public void run2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        User user = (User)context.getBean("user");
        user.flay();
    }

    @org.junit.Test
    public void run3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Cat cat = (Cat)context.getBean("cat");
        cat.run();
    }

    @org.junit.Test
    public void run4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Dog dog = (Dog)context.getBean("dog");
        dog.jump();
    }
}

<?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.xsd">

    <!-- IOC管理对象的方式-->
    <!-- Spring基于xml的方式去创建对象-->
<!--    <bean id="demo" class="com.qcby.Demo"/>-->
<!--    <bean id="user" class="com.qcby.User"/>-->

    <!-- 扫描com.qcby下有哪些类，获取全类名，方便创建对象-->
    <context:component-scan base-package="com.qcby"/>
</beans>

1.2.3 注入属性

基于xml的方式

package com.qcby;


public class Cat {
    //简单类型
    private int age;
    private Integer num;
    private double height;
    private String name;
    private Demo demo;

    public int getAge() {
        return age;
    }

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

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

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

    public Demo getDemo() {
        return demo;
    }

    public void setDemo(Demo demo) {
        this.demo = demo;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", num=" + num +
                ", height=" + height +
                ", name='" + name + '\'' +
                ", demo=" + demo +
                '}';
    }

    public void run(){
        System.out.println("猫跑的很快……");
    }
}

package com.qcby;


import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class Dog {
    //复杂类型
    private int[] arr;
    private List<String> list;
    private Map<String,String> map;

    public int[] getArr() {
        return arr;
    }

    public void setArr(int[] arr) {
        this.arr = arr;
    }

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

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

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "arr=" + Arrays.toString(arr) +
                ", list=" + list +
                ", map=" + map +
                '}';
    }

    public void jump(){
        System.out.println("狗跳的很高");
    }
}

<?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.xsd">

    <!-- IOC管理对象的方式-->
    <!-- Spring基于xml的方式去创建对象-->
    <bean id="demo" class="com.qcby.Demo"/>
<!--    <bean id="user" class="com.qcby.User"/>-->
    <!--通过get/set方法-->
    <bean id="cat" class="com.qcby.Cat">
        <!--property：完成属性注入的标签  name：要赋值的属性名称  value：要赋值的值  ref：用来做对象映射-->
        <property name="age" value="10"/>
        <property name="num" value="100"/>
        <property name="name" value="小白"/>
        <property name="height" value="10.27"/>
        <property name="demo" ref="demo"/><!-- 写这行是要先把第9行写上-->
    </bean>

    <bean id="dog" class="com.qcby.Dog">
        <property name="arr">
            <array>
                <value>11</value>
                <value>12</value>
                <value>100</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>熊大</value>
                <value>熊二</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="aaa" value="a"/>
                <entry key="bbb" value="b"/>
            </map>
        </property>
    </bean>

    <!--通过构造器-->
    <bean id="user" class="com.qcby.User">
        <constructor-arg name="height" value="56.1"></constructor-arg>
        <constructor-arg name="name" value="小红"></constructor-arg>
        <constructor-arg name="demo" ref="demo"></constructor-arg>
    </bean>
    

    <!-- 扫描com.qcby下有哪些类，获取全类名，方便创建对象-->
<!--    <context:component-scan base-package="com.qcby"/>-->
</beans>

import com.config.SpringConfig;
import com.qcby.Cat;
import com.qcby.Demo;
import com.qcby.Dog;
import com.qcby.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class Test {

    /**
     *  传统创建对象的方式
     *  人为手动创建，每次获取对象需要new对象
     */
    @org.junit.Test
    public void run(){
        Demo demo = new Demo();
        demo.hello();
    }

    /**
     * IOC
     * 启动Spring项目的时候，Spring创建的
     * 并且会将创建的对象放在一个IOC容器中，每次需要时只用从IOC里面获取
     */
    @org.junit.Test
    public void run1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Demo demo = (Demo)context.getBean("demo");
        demo.hello();
    }

    @org.junit.Test
    public void run2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        User user = (User)context.getBean("user");
        user.flay();
        System.out.println(user);
    }

    @org.junit.Test
    public void run3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Cat cat = (Cat)context.getBean("cat");
        cat.run();
        System.out.println(cat);
    }

    @org.junit.Test
    public void run4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Dog dog = (Dog)context.getBean("dog");
        dog.jump();
        System.out.println(dog);
    }
}

基于注解的方式

package com.qcby;

import org.springframework.stereotype.Service;

@Service
public class Demo {
    public void hello(){
        System.out.println("hello world");
    }
}

package com.qcby;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class Cat {
    //简单类型
    @Value(value="10")
    private int age;
    @Value(value="100")
    private Integer num;
    @Value(value="104.5")
    private double height;
    @Value(value="张三")
    private String name;
    @Autowired   //这个会自动映射
    private Demo demo;

    public int getAge() {
        return age;
    }

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

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

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

    public Demo getDemo() {
        return demo;
    }

    public void setDemo(Demo demo) {
        this.demo = demo;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", num=" + num +
                ", height=" + height +
                ", name='" + name + '\'' +
                ", demo=" + demo +
                '}';
    }

    public void run(){
        System.out.println("猫跑的很快……");
    }
}

<?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.xsd">

    <!-- IOC管理对象的方式-->
    <!-- Spring基于xml的方式去创建对象-->
<!--    <bean id="demo" class="com.qcby.Demo"/>-->
<!--    <bean id="user" class="com.qcby.User"/>-->
    <!--通过get/set方法-->
<!--    <bean id="cat" class="com.qcby.Cat">-->
<!--        <!&ndash;property：完成属性注入的标签  name：要赋值的属性名称  value：要赋值的值  ref：用来做对象映射&ndash;>-->
<!--        <property name="age" value="10"/>-->
<!--        <property name="num" value="100"/>-->
<!--        <property name="name" value="小白"/>-->
<!--        <property name="height" value="10.27"/>-->
<!--        <property name="demo" ref="demo"/><!&ndash; 写这行是要先把第9行写上&ndash;>-->
<!--    </bean>-->

<!--    <bean id="dog" class="com.qcby.Dog">-->
<!--        <property name="arr">-->
<!--            <array>-->
<!--                <value>11</value>-->
<!--                <value>12</value>-->
<!--                <value>100</value>-->
<!--            </array>-->
<!--        </property>-->
<!--        <property name="list">-->
<!--            <list>-->
<!--                <value>熊大</value>-->
<!--                <value>熊二</value>-->
<!--            </list>-->
<!--        </property>-->
<!--        <property name="map">-->
<!--            <map>-->
<!--                <entry key="aaa" value="a"/>-->
<!--                <entry key="bbb" value="b"/>-->
<!--            </map>-->
<!--        </property>-->
<!--    </bean>-->

<!--    <!&ndash;通过构造器&ndash;>-->
<!--    <bean id="user" class="com.qcby.User">-->
<!--        <constructor-arg name="height" value="56.1"></constructor-arg>-->
<!--        <constructor-arg name="name" value="小红"></constructor-arg>-->
<!--        <constructor-arg name="demo" ref="demo"></constructor-arg>-->
<!--    </bean>-->
    

    <!-- 扫描com.qcby下有哪些类，获取全类名，方便创建对象-->
    <context:component-scan base-package="com.qcby"/>
</beans>

import com.config.SpringConfig;
import com.qcby.Cat;
import com.qcby.Demo;
import com.qcby.Dog;
import com.qcby.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    /**
     *  传统创建对象的方式
     *  人为手动创建，每次获取对象需要new对象
     */
    @org.junit.Test
    public void run(){
        Demo demo = new Demo();
        demo.hello();
    }

    /**
     * IOC
     * 启动Spring项目的时候，Spring创建的
     * 并且会将创建的对象放在一个IOC容器中，每次需要时只用从IOC里面获取
     */
    @org.junit.Test
    public void run1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Demo demo = (Demo)context.getBean("demo");
        demo.hello();
    }

    @org.junit.Test
    public void run2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        User user = (User)context.getBean("user");
        user.flay();
        System.out.println(user);
    }

    @org.junit.Test
    public void run3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Cat cat = (Cat)context.getBean("cat");
        cat.run();
        System.out.println(cat);
    }

    @org.junit.Test
    public void run4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Dog dog = (Dog)context.getBean("dog");
        dog.jump();
        System.out.println(dog);
    }
}

1.2.4 纯注解开发

package com.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(value = "com.qcby")
public class SpringConfig {

}

Test类中按这种方式写

@org.junit.Test
public void run3(){
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    Cat cat = (Cat)context.getBean("cat");
    cat.run();
    System.out.println(cat);
}

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。