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

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);
}