Spring框架介绍

最新推荐文章于 2024-09-29 12:06:46 发布
最新推荐文章于 2024-09-29 12:06:46 发布
阅读量328 收藏
点赞数
分类专栏： 开发框架 文章标签： spring 框架 IOC AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/juligang320/article/details/53445459
版权

一、用分层思想实现程序结构优化

(1)这是一个基于SSH框架的网站文件布局

代码结构

(2)以下是一个基于SSH框架的网站流程图

SSH框架流程图

(3)以下是一个基于SSM框架的网站流程图

SSM框架流程图

二、Spring IOC功能详述

1.注解方式实现IOC

使用注解方式之前，在applicationContext.xml里面加上一下配置：

<!-- 自动装配 -->
<context:annotation-config/>
<!-- 指定组件的路径 -->
<context:component-scan base-package="com.juligang.dao.impl,com.juligang.service.impl,com.juligang.action.UserAction"></context:component-scan>

Action层

package com.juligang.action;

import java.io.IOException;
import java.io.PrintWriter;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.struts2.ServletActionContext;

import com.juligang.model.User;
import com.juligang.service.UserService;

public class UserAction {
    User user;
    UserService service;       //调用Service层
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    public UserService getService() {
        return service;
    }
    @Resource(name="service")       //通过注解方式注入service
    public void setService(UserService service) {
        this.service = service;
    }

    public String addOrUpdate()
    {
        service.add(user);
        return login();
    }

    public String checkExist()
    {
        user=service.check(user);
        HttpServletResponse response=ServletActionContext.getResponse();
        try {
            PrintWriter out=response.getWriter();
            if(null!=user)
            {
                out.print("YES!"+user.getId());
            }
            else
            {
                out.print("NO!"+user.getId());
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    public String login()
    {
        //context只在一次请求时有效
        //ActionContext context=ActionContext.getContext();
        //context.put("USER", user);
        HttpServletRequest request=ServletActionContext.getRequest();
        HttpSession session=request.getSession();
        session.setAttribute("USER", user);
        return "main";
    }

    public String exit()
    {
        HttpServletRequest request=ServletActionContext.getRequest();
        HttpSession session=request.getSession();
        session.setAttribute("USER", null);
        return "main";
    }
}

Service实现层

package com.juligang.service.impl;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;

import com.juligang.dao.UserDAO;
import com.juligang.model.User;
import com.juligang.service.UserService;
@Component(value="service")        //通过注解建立一个service实现类，共Action层装配
public class UserServiceImpl implements UserService {
    UserDAO dao;
//  这是构造函数方式注入  
//  public UserServiceImpl(UserDAO dao) {
//      super();
//      this.dao = dao;
//  }

//  这是setter方式注入
    public UserDAO getDao() {
        return dao;
    }
    @Resource(name="sqlDAO")            //通过注解给DAO装配一个实现类
                                       //可以装配sqlDAO，也可装配fileDAO
    public void setDao(UserDAO dao) {
        this.dao = dao;
    }

    @Override
    public void add(User user) {
        // TODO Auto-generated method stub
        dao.save(user);
    }
    @Override
    public User check(User user) {
        // TODO Auto-generated method stub
        return dao.check(user);
    }
}

DAO实现层

（1）MySQL实现层

package com.juligang.dao.impl;

import javax.annotation.Resource;

import org.springframework.orm.hibernate4.HibernateTemplate;
import org.springframework.stereotype.Component;

import com.juligang.dao.UserDAO;
import com.juligang.model.User;

@Component(value="sqlDAO")               //DAO实现类1
public class UserDAOMySqlImpl implements UserDAO {
    HibernateTemplate hibernateTemplate;
    @Resource
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }

    @Override
    public void save(User user) {
        hibernateTemplate.merge(user);
    }

    @Override
    public User check(User user) {
        // TODO Auto-generated method stub
        return hibernateTemplate.findByExample(user).get(0);
    }

}

（2）File实现类 

package com.juligang.dao.impl;

import java.io.FileWriter;
import java.io.IOException;

import org.springframework.stereotype.Component;

import com.juligang.dao.UserDAO;
import com.juligang.model.User;

@Component(value="fileDAO")             //DAO实现类2
public class UserDAOFileImpl implements UserDAO {

    @Override
    public void save(User user) {
        // TODO Auto-generated method stub
        FileWriter fw;
        try {
            fw = new FileWriter("e:\\Users.txt",true);
            fw.write(user.getName()+":"+user.getPwd());
            fw.write("\r\n");
            fw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public User check(User user) {
        // TODO Auto-generated method stub
        return user;

    }
}

注解方式总结：
Action层
@Resource(name=”userService”) //装配对象

Service实现层
@Component(value=”userService”) //初始化一个对象

@Resource(name=”sqlDAO”)

DAO实现层
@Component(value=”sqlDAO”)

@Component(value=”fileDAO”)

注意:如果把Component里面的value和Resource里面的name省略掉，那么默认值为类的第一个字母小写全称

这也是基于分层思想的技术实现

2.XML方式实现IOC
与注解方式实现的效果一样，只是把装配控制权交给了XML配置文件
IoC=控制反转=inverse of control
注解方式控制权在源代码中，通过这种方式，控制权在配置文件中
DI =依赖注入=dependency injection

同样是上面的程序
去掉@Component和@Resource注解，这些定义和装配的任务都放在.xml文件中

<!-- UserDAOFileImpl类实例一个对象filedao，以下类似 --> 
<bean id="fileDAO" class="com.juligang.dao.impl.UserDAOFileImpl"></bean>
<bean id="sqlDAO" class="com.juligang.dao.impl.UserDAOMySqlImpl"></bean>
    <!-- service是Action中的属性，依赖于dao的注入 -->
<bean id="service" class="com.juligang.service.impl.UserServiceImpl">
        <!-- dao是service实现类中的属性，依赖于dao的实现类注入 -->
        <property name="dao" ref="sqlDAO"></property>
    </bean>

不能像注解方式那样一层一层往上装配。

3.Spring IoC的基本原理
inverse of control = 控制反转
dependency injection = 依赖注入

帮我们创建对象，帮我们组织和装配对象

1.自动装配
autowire :byName,byType
（1）默认的装配方式

<bean id="fileDAO" class="com.juligang.dao.impl.UserDAOFileImpl"></bean>
<bean id="sqlDAO" class="com.juligang.dao.impl.UserDAOMySqlImpl"></bean>
<bean id="service" class="com.juligang.service.impl.UserServiceImpl">
    <property name="dao" ref="sqlDAO"></property>
</bean>

（2）自动装配autowire :byName

<bean id="dao" class="com.juligang.dao.impl.UserDAOFileImpl"></bean>
<bean id="service" class="com.juligang.service.impl.UserServiceImpl"  autowire="byName">
</bean>

UserServiceImpl类中有一个属性dao，需要注入，我们设置autowire=”byName”，所以Spring会自动去寻找跟dao名字相同的实现进行装配
由于dao有2个实现类，你要装配哪个，就把那个实例成dao
（3）自动装配autowire :byType

<bean id="fileDAO" class="com.juligang.dao.impl.UserDAOFileImpl"></bean>
<bean id="sqlDAO" class="com.juligang.dao.impl.UserDAOMySqlImpl"></bean>
<bean id="service" class="com.juligang.service.impl.UserServiceImpl autowire="byType"">
</bean>

由于dao的实现类有两个，如果根据Type去自动装配会出问题，如果只有一个实现类，那么与根据Name装配效果一样

default-autowire:byname,byType
它是beans的一个属性，bean的属性autowire类似，不再举例 

public class UserServiceImpl implements UserService {
    UserDAO dao;
//  这是构造函数方式注入  
//  public UserServiceImpl(UserDAO dao) {
//      super();
//      this.dao = dao;
//  }

//  这是setter方式注入
    public UserDAO getDao() {
        return dao;
    }
    @Resource(name="sqlDAO")            
    public void setDao(UserDAO dao) {
        this.dao = dao;
    }

被注释的代码采用的就是构造函数方式注入的，不过xml文件的配置也不同，如下：

<bean id="fileDAO" class="com.juligang.dao.impl.UserDAOFileImpl"></bean>
<bean id="sqlDAO" class="com.juligang.dao.impl.UserDAOMySqlImpl"></bean>
<bean id="service" class="com.juligang.service.impl.UserServiceImpl">
    <constructor-arg name="dao" ref="sqlDAO"></constructor-arg >
</bean>

3.不同属性的注入方式，只做了解
简单属性注入：int,String,float
集合属性注入：Map，List，Set

4.bean的单实例与多实例属性

scope = singleton,prototype,request,session,global session
默认是singleton 单例,prototype 原型，模板

比较两个类的区别

class Student
{
   private int age;
   public void setAge(int age)
   {
       this.age=age;
   }
   public void show()
   {
       System.out.println(age);
   }
}

class StudentDAO
{
    public void save(Student student)
    {
       ......
    }
}

Student zhang=new Student();
zhang.setAge(20);

Student lee=new Student();
lee.setAge(18);

这种有参的类，不能是单实例，否则每个实例都一样，会有问题。

5.延时加载
lazy-init 容器加载时不初始化
default-lazy-init

6.初始化方法和销毁方法
init-method 和 destroy-method
在类中写一个初始化方法和一个销毁方法，在bean的属性中加以说明，如果方法初始化或完成时会被调用到。

三、Spring AOP功能详述

  1. AOP基本原理及面向切面编程的实现
    复习动态代理，

作用：可以在现有方法之上添加代码，增加现有程序的功能。

讲好处！

1.将与业务无关的通用功能抽取出来，单独编写，
开发人员可以专注于业务逻辑的编写。
这些通用功能包括日志，权限管理，事务处理，异常处理等。

2.通用功能的增加与删除，可以通过配置文件进行配置。

3.是一种编程方式的革命！

引入AOP：面向切面的编程

AOP=面向切面编程=Aspect Oriented Programming

技术原理：动态代理

之前讲过的OOP
OOP=面向对象编程=Object Oriented Programming

AOP 类似jsp中的filter(过滤器)，struts2中的interceptor（拦截器）

注解配置,XML配置

（1）学习在注解方式使用aop

这个功能应该加在哪个类的哪个方法上？？是加在方法执行之前，还是之后？？

@Before(“execution(public void net.xinqushi.service.impl.save(net.xinqushi.model.User))”)
这里写图片描述
spring中使用了一套面向aop编程的框架，叫做aspectj。

修改spring配置文件applicationContext.xml
添加AOP的命名空间及xml约束文件
xmlns:aop=”http://www.springframework.org/schema/aop”

http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd

增加支持注解功能

  1. AOP详解及通过XML配置实现的方法
    Spring AOP 的一些术语

    切面（Aspect）
    要增加什么功能？事务管理，日志管理，权限管理，异常处理

    连接点（Joinpoint）
    哪个类的哪个方法上增加功能？

    通知（Advice）
    加在方法的什么位置？前面？后面？产生异常时？环绕？？

    切入点（Pointcut）
    给连接点命名，便于在多处使用。

    目标对象（Target Object）
    被代理对象，自己的功能不够强大，要通过aop加强。

    AOP代理（AOP Proxy）
    功能已经加强的哪个对象

    织入（Weaving）
    把新功能和本身的功能组织在一起执行。

1.joinpoint语法：用一些通配符来定义在哪些类和方法上增加aop功能。

语法：
1).execution(public * *(..))
所有public方法

2).execution(* set*(..))
所有以set作为方法名开头的方法

3).exuection(* com.xzy.service.AccountService.*(..))
com.xzy.service.AccountService类中的所有方法

4).execution(* com.xyz.service..(..))
com.xyz.service包中所有类的所有方法

5).execution(* com.xyz.service...(..))
com.xyz.service包及子包下的所有类的所有方法

2.pointcut：给joinpoint取个名字。
@pointcut(“execution( * com.xzy..(..))”)
public void businessService(){}
这里写图片描述
3.advice

@Before
@AfterReturning
@AfterThrowing
@After(finally)
@Around

4.JoinPoint jp
ProceedingJointPoint pjp
定义了Pointcut之后，很多方法都可以添加此切面，无法区分。所以可以给方法传入参数，切面执行时可以带上方法本身特有的属性加以与其他方法区分。
这里写图片描述
5.xml配置AOP

<bean id="log" class="com.juligang.aop.Log"></bean>         //初始化一个切面对象
<aop:config>
   <aop:aspect ref="log">      //装配一个切面
     <aop:pointcut          //定义切入点
            expression="execution(* net.xinqushi.dao.impl.*.*(..))" id="pt"/>       
<aop:before method="before" pointcut-ref="pt"/>
    <aop:after method="after" pointcut-ref="pt"/>
   </aop:aspect>
</aop:config>
行云的逆袭
关注
专栏目录
Spring框架介绍及使用
qq_22583741的博客
03-17 39万+
Spring框架—控制反转（IOC） 1 Spring框架概述 1.1 什么是Spring 1.2 Spring的优点 1.3 Spring的体系结构 2 入门案例:（IoC） 2.1导入jar包 2.2目标类 2.3 配置文件 2.4测试 3 入门案例：DI 3.1 目标类 3.2 dao 3.3 service 3.4 配置文件 3.5 测试 4 依赖注入...
JAVA 中的Spring框架介绍包括起源、体系结构、核心部分、特点等
03-29
### JAVA 中的Spring框架介绍包括起源、体系结构、核心部分、特点等 #### 一、Spring框架概述 Spring是一款主流的Java EE轻量级开源框架，由“Spring之父”Rod Johnson提出并创立，旨在简化Java企业级应用的开发...
Spring框架简单介绍
qq_61353850的博客
04-19 2557
1、Spring框架的概述： Spring是一个开源代码的设计层面框架，解决的是业务逻辑和其他各层次的松耦合问题，主要的思想是面向接口编程。 Spring的核心是控制权反转（IOC）和面向切面（AOP），Spring是一个分层的JavaSE/EEfull-stack（一站式）轻量级开源框架 IOC:控制权反转，将创建对象的过程交给Spring进行管理 AOP：面向切面，在不修改源代码的情况下进行代码功能的增强 2、Spring的优点 方便解耦，简化开发，Spring是一个大工厂，可以将所有对象的
Java Spring框架介绍，5分钟一看就会
qq_50838572的博客
02-19 2208
spring框架
Spring框架详解
热门推荐
m0_63324772的博客
04-12 5万+
Spring框架详解（五万字）入门级 简介Spring5框架 内容介绍： 1.Spring概念 2.IOC容器 3.Aop 4.JDBCTEmplate 5.事物管理 6.Spring5新特性
Spring框架
Mr_Jin的博客
12-02 4391
spring框架：负责宏观调控，负责整合其他的第三方的框架 IOC介绍 IOC是一种控制反转的设计思想，由spring容器管理对象的生命周期，降低代码的耦合性。 将所有的对象都交给spring容器管理，容器负责对象的注入 DI介绍：Dependency Injection 依赖注入 spring容器替你管理一系列需要的类，前提是你需要将这些类表示交给容器进行管理才可，然后在你需要的时候不用自己去定义，容器就会自动帮你进行实例化 实现IOC思想需要DI进行注入。 注入的方式最常用的就是@A...
spring框架--全面详解（学习笔记）
swy2560666141的博客
02-26 1万+
由 Spring IoC 容器管理的对象称为 Bean，Bean 根据 Spring 配置文件中的信息创建。可以把 Spring IoC 容器看作是一个大工厂，Bean 相当于工厂的产品，如果希望这个大工厂生产和管理 Bean，则需要告诉容器需要哪些 Bean，以及需要哪种方式装配 Bean。Spring 配置文件支持两种格式，即 XML 文件格式和 Properties 文件格式。
【精选】Spring框架介绍及Spirng各个版本的特性
guojiaqi_的博客
11-30 4325
Spring框架英文全称Spring Framework，是由Spring团队研发的模块化、轻量级开源框架。其主要目的是为了简化项目开发。在项目开发中，可以说没有刻意使用Spring，却处处有着Spring存在。用官网对Spring框架的介绍：Spring框架核心功能包含依赖注入、事务管理、Web应用、数据访问、消息发送等等。
【Spring】Spring框架介绍，功能模块，容器知识和有关Spring的生态圈的详细讲解
2201_75366661的博客
06-12 3087
【Spring】Spring的框架介绍，功能模块，Spring的七大优点、Spring的容器知识和有关Spring的生态圈等详细讲解，另含Spring是怎么样引导配置的拓展
spring框架特点
weixin_57176230的博客
04-25 6177
框架特点 1.方便解耦、简化开发 通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造 成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写 代码，可以更专注于上层的应用。 2.AOP编程支持 通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通 过AOP轻松应付。 3.声明式事务的支持 在Spring中，我们可以...
spring学习之spring框架介绍
那一年的雪花飘落，梅花开枝头。
10-21 3798
spring学习之spring框架介绍开始spring如果你是刚使用spring的开发人员，可以先使用spring-boot来创建一个spring应用。他基于spring框架。主张约定优于配置。被设计成为尽可能快的运行。 参考代码及文档 快速学习spring指南 学习建立一个符合restful规范的web应用spring框架的介绍spring框架是一个java平台项目，他为java应用提供了基
Spring框架介绍ppt
03-01
博文链接：https://pingpangsong.iteye.com/blog/38292
spring框架api中文版.zip(spring开发手册）
04-06
介绍Spring框架 1.1。 依赖注入和控制反转 1.2。 模块 1.2.1。 核心容器 1.2.2。 数据访问/集成 1.2.3。 web 1.2.4。 AOP和仪表 1 2 5。 测试 1.3。 使用场景 1.3.1。 依赖关系管理和命名约定 Spring依赖和依靠弹簧...
阿博图书馆管理：SpringBoot实战指南
2402_85761468的博客
09-27 685
MySQL数据库中数据的分表分库存储方式能够最大程度的避免数据同步代码的性能损耗，使得数据库的存取速度有了很大提升，而且同时保持了很大的灵活性。通过对系统功能模块分析可以得知，主要是对项目元素组合、分解和更换做出相应的单元，再通过系统模块来规划出一个原则，系统的设计首先是围绕用户需求进行开发设计的，主要是为了能够更好的管理信息和方便用户，其次就是围绕阿博图书馆管理系统进行设计，最终的设计必须要满足用户的需求，这样才能够实现系统的最大意义和价值，并且在设计的时候一定要避免代码相互重复的情况发生。
springboot+neo4j demo
极客栈
09-27 606
这个简单的示例展示了如何在Spring Boot应用中集成Neo4j，包括创建节点实体、使用Neo4j仓库接口以及创建一个简单的REST控制器。这个示例可以作为开发者学习和实践Spring Boot与Neo4j集成的起点。以下是一个简单的Spring Boot与Neo4j集成的示例代码。
基于SpringBoot原创歌曲分享平台设计与实现
zhshx19900318的博客
09-29 824
在这样的背景下人类社会进入了全新的信息化的时代。在音乐分享管理页面中可以查看索引,音乐分类，音乐名称，音乐视频，区域，视频封面，发布时间，歌词，用户账号，用户姓名等内容，并进行详情，修改，查看评论和删除操作；在举报管理页面中可以查看索引,音乐名称，发布时间，用户账号，用户姓名，举报原因，审核回复，审核状态，审核等内容，并进行详情，修改，删除操作；
Spring Security 是一个强大的和高度可定制的身份验证和访问控制框架。它是 Spring 项目家族的一员，用于构建安全的 Java 应用程序。
weixin_64446270的博客
09-27 1399
Spring Security 是一个强大的和高度可定制的身份验证和访问控制框架。它是 Spring 项目家族的一员，用于构建安全的 Java 应用程序。Spring Security 提供了全面的安全服务，从基本的登录认证到复杂的访问控制，几乎涵盖了所有与安全相关的需求。
spring-boot 整合 mybatis
最新发布
m0_72168501的博客
09-29 445
spring boot 整合 mybatis
微服务--SpringAMQP
weixin_51933701的博客
09-27 1293
高级消息队列协议，是应用程序之间传递业务消息的开放标准，与语言和平台无关，更符合微服务架构中独立性的要求。：基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息。是基础抽象，是底层的默认实现。SpringAMQP利用SpringBoot实现了自动装配，使用非常方便。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

行云的逆袭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值