Spring超级详细的笔记
spring 笔记,
补充:
struts2
hibernate 配置文件:xml --- 可扩展的标记语言:由标签组成,标签名任意。<d a="zhj">abcdefg</d>
<bean id="stu" class="com.c28.spring.inject.Student">
<property name="id">
<value>22</value>
</property>
<property name="name">
<value>zhj_22</value>
<!-- per2中有一个类型为Student的属性,则此Student类型的bean会自动注入给per2 -->
<bean id="student" class="com.c28.spring.inject.Student">
<property name="id">
<value>11</value>
=============================================================================================
2.工厂模式:工厂类
工厂类:生产对象
工厂类好处:解耦合。
1.添加配置:
ud=erDAOImpl
//2.通过工厂类获取bean
Java相关课程系列笔记之十五Spring学习笔记(建议用WPS打开)
Spring学习笔记Java相关课程系列笔记之十五笔记内容说明Spring(梁建全老师主讲,占笔记内容100%);目录一、 Spring概述 (1)Spring框架的作用 (1)Spring框架的优点 (1)Spring框架的容器 (1)二、 Spring容器的基本应用 (2)如何将一个Bean组件交给Spring容器 (2)如何获取Spring容器对象和Bean对象 (2)如何控制对象创建的模式 (2)Bean对象创建的时机 (2)为Bean对象执行初始化和销毁方法 (2)案例:Spring框架的使用以及节节整合测试 (3)三、 Spring框架IoC特性 (5)IoC概念 (5)DI概念 (5)案例:测试IoC(set注入) (5)案例:测试IoC(构造注入) (6)案例:不用JDBC访问数据库,而是采用Hibernate访问 (6)四、 Spring中各种类型的数据注入 (7)Bean对象注入 (7)基本数据的注入 (7)集合的注入 (7)案例:各类数据注入 (7)五、 AOP概念 (10)什么是AOP (10)AOP和OOP的区别 (10)AOP相关术语 (10)案例:AOP的使用,模拟某些组件需要记录日志的功能 (11)通知类型 (11)切入点 (12)案例:环绕通知,修改案例使之动态显示所执行的操作 (12)案例:利用AOP实现异常处理,将异常信息写入文件 (13)六、 Log4j日志记录工具 (14)Log4j介绍 (14)Log4j的使用 (14)案例:修改案例,使用Log4j记录日志 (14)七、 Spring注解配置 (16)组件扫描功能 (16)组件扫描的使用方法 (16)注入注解标记使用方法 (17)AOP注解标记使用方法 (17)八、 Spring对数据访问技术的支持 (19)Spring提供了统一的异常处理类型 (19)Spring提供了编写DAO的支持类 (19)Spring提供了声明式事务管理方法 (19)Spring框架如何使用JDBC技术 (19)连接池优点 (22)Spring框架如何使用Hibernate技术 (22)Spring+Hibernate如何使用Session、Query等对象 (25)Spring框架和Struts2整合应用 (25)案例:采用SSH结构重构资费管理模块 (27)九、整合开发包 (31)Struts2创建对象的方式 (31)创建对象的方式 (31)的内部实现 (31)原理图1 (31)原理图2 (32)注意事项 (32)注入规则 (32)十、 Spring的事务管理 (33)声明式事务管理(基于配置方式实现事务控制) (33)编程式事务管理(基于Java编程实现事务控制),不推荐用! (34)Spring中常用的事务类型 (34)十一、 Spring的MVC (35)Spring MVC的体系结构 (35)Spring MVC的工作流程 (35)案例:简易登录(基于XML配置,不推荐使用) (35)案例:修改案例(基于注解配置,推荐使用) (37)十二、其他注意事项 (39)Spring的核心模块 (39)表单中action属性的相对、绝对路径问题 (39)用SSH重构NetCTOSS项目模块的步骤 (39)一、Spring概述我们学习Spring框架的最终目的是用它整合Struts2、Hibernate框架(SSH)。
Spring学习笔记(一)
Spring学习笔记(⼀)Spring学习笔记(⼀)这是⼀个沉淀的过程,⼤概第⼀次接触Spring是在去年的这个时候,当初在实训,初次接触Java web,直接学习SSM框架(当是Servlet都没有学),于是,养成了⼀个很不好的学习习惯,就是“照猫画虎”。
别⼈做什么,照着样⼦就是了,没有任何的思考,这样的学习习惯肯定不会⾛太远。
现在我产⽣很多疑惑,这是什么?为什么这么做?如何做的更好?因此这次笔记的主题就是《这是什么?》1. spring框架概述1.1 什么是springSpring是⼀个开源框架,Spring是于2003 年兴起的⼀个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍⽣⽽来。
它是为了解决企业应⽤开发的复杂性⽽创建的。
框架的主要优势之⼀就是其分层架构,分层架构允许使⽤者选择使⽤哪⼀个组件,同时为 J2EE 应⽤程序开发提供集成的框架。
Spring使⽤基本的JavaBean 来完成以前只可能由EJB完成的事情。
然⽽,Spring的⽤途不仅限于服务器端的开发。
从简单性、可测试性和松耦合的⾓度⽽⾔,任何Java应⽤都可以从Spring中受益。
Spring的核⼼是控制反转(IoC)和⾯向切⾯(AOP)。
简单来说,Spring是⼀个分层的JavaSE/EE full-stack(⼀站式) 轻量级开源框架。
[^摘⾃]: (百度百科)轻量级:与EJB对⽐,依赖资源少,销毁的资源少。
分层:⼀站式,每⼀个层都提供的解决⽅案1.2 spring由来Expert One-to-One J2EE Design and DevelopmentExpert One-to-One J2EE Development without EJB1.3 spring核⼼Spring的核⼼是控制反转(IoC)和⾯向切⾯(AOP)1.4 spring优点⽅便解耦,简化开发(⾼内聚低耦合)Spring就是⼀个⼤⼯⼚(容器),可以将所有对象创建和依赖关系维护,交给Spring管理spring⼯⼚是⽤于⽣成beanAOP编程的⽀持Spring提供⾯向切⾯编程,可以⽅便的实现对程序进⾏权限拦截、运⾏监控等功能声明式事务的⽀持只需要通过配置就可以完成对事务的管理,⽽⽆需⼿动编程⽅便程序的测试Spring对Junit4⽀持,可以通过注解⽅便的测试Spring程序⽅便集成各种优秀框架Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz等)的直接⽀持降低JavaEE API的使⽤难度Spring 对JavaEE开发中⾮常难⽤的⼀些API(JDBC、JavaMail、远程调⽤等),都提供了封装,使这些API应⽤难度⼤⼤降低1.5 spring体系结构Spring框架是⼀个分层架构,它包含⼀系列的功能要素并被分为⼤约20个模块。
Spring学习笔记
Spring学习笔记Java相关课程系列笔记之十五笔记内容说明Spring(梁建全老师主讲,占笔记内容100%);目录一、Spring概述 (1)1.1 Spring框架的作用 (1)1.2 Spring框架的优点 (1)1.3 Spring框架的容器 (1)二、Spring容器的基本应用 (2)2.1如何将一个Bean组件交给Spring容器 (2)2.2如何获取Spring容器对象和Bean对象 (2)2.3如何控制对象创建的模式 (2)2.4 Bean对象创建的时机 (2)2.5为Bean对象执行初始化和销毁方法 (2)2.6案例:Spring框架的使用以及2.1节-2.5节整合测试 (3)三、Spring框架IoC特性 (5)3.1 IoC概念 (5)3.2 DI概念 (5)3.3案例:测试IoC(set注入) (5)3.4案例:测试IoC(构造注入) (6)3.5案例:不用JDBC访问数据库,而是采用Hibernate访问 (6)四、Spring中各种类型的数据注入 (7)4.1 Bean对象注入 (7)4.2基本数据的注入 (7)4.3集合的注入 (7)4.4案例:各类数据注入 (7)五、AOP概念 (10)5.1什么是AOP (10)5.2 AOP和OOP的区别 (10)5.3 AOP相关术语 (10)5.4案例:AOP的使用,模拟某些组件需要记录日志的功能 (11)5.5通知类型 (11)5.6切入点 (12)5.7案例:环绕通知,修改5.4案例使之动态显示所执行的操作 (12)5.8案例:利用AOP实现异常处理,将异常信息写入文件 (13)六、Log4j日志记录工具 (14)6.1 Log4j介绍 (14)6.2 Log4j的使用 (14)6.3案例:修改5.8案例,使用Log4j记录日志 (14)七、Spring注解配置 (16)7.1组件扫描功能 (16)7.2组件扫描的使用方法 (16)7.3注入注解标记使用方法 (17)7.4 AOP注解标记使用方法 (17)八、Spring对数据访问技术的支持 (19)8.1 Spring提供了统一的异常处理类型 (19)18.2 Spring提供了编写DAO的支持类 (19)8.3 Spring提供了声明式事务管理方法 (19)8.4 Spring框架如何使用JDBC技术 (19)8.5连接池优点 (22)8.6 Spring框架如何使用Hibernate技术 (22)8.7 Spring+Hibernate如何使用Session、Query等对象 (25)8.8 Spring框架和Struts2整合应用 (25)8.9案例:采用SSH结构重构资费管理模块 (27)九、整合开发包struts-spring-plugin.jar (32)9.1 Struts2创建对象的方式 (32)9.2 struts-spring-pligin.jar创建对象的方式 (32)9.3 struts-spring-plugin.jar的内部实现 (32)9.4原理图1 (32)9.5原理图2 (33)9.6注意事项 (33)9.7注入规则 (33)十、Spring的事务管理 (34)10.1声明式事务管理(基于配置方式实现事务控制) (34)10.2编程式事务管理(基于Java编程实现事务控制),不推荐用! (35)10.3 Spring中常用的事务类型 (35)十一、Spring的MVC (36)11.1 Spring MVC的体系结构 (36)11.2 Spring MVC的工作流程 (36)11.3案例:简易登录(基于XML配置,不推荐使用) (36)11.4案例:修改11.3案例(基于注解配置,推荐使用) (38)十二、其他注意事项 (40)12.1 Spring的核心模块 (40)12.2表单中action属性的相对、绝对路径问题 (40)12.3用SSH重构NetCTOSS项目模块的步骤 (40)2Spring概述我们学习Spring框架的最终目的是用它整合Struts2、Hibernate框架(SSH)。
100-Spring学习笔记-面试题
100-Spring学习笔记-⾯试题⼀、基本概念1、Spring优点1.1、轻量级、⾮⼊侵式:对现有的类结构没有影响1.2、可以提供众多服务,如事务管理,WS等1.3、对主流的框架提供了很多的集成⽀持,如hibernate,Struts2,像⼀个胶⽔⼀样,把⼀些好的框架粘合在⼀起⽅便实⽤。
1.4、使⽤Spring的IOC容器,将对象之间的依赖关系交给Spring,降低组件之间的耦合性,让我们更专注于应⽤逻辑1.5、Spring DI 机制降低了业务对象替换的复杂性1.6、Spring的⾼度可开放性,并不强制依赖于Spring,开发者可以⾃由选择Spring部分或全部2、Spring缺点2.1、没有SpringBoot好⽤⼆、Spring类1、ApplicationContext1.1、FileSystemXmlApplicationContext1.2、ClassPathXmlApplicationContext1.3、WebXmlApplicationContext三、SpringMVC1、执⾏流程1.1、⽤户发送请求⾄前端控制器DispatcherServlet1.2、DispatcherServlet收到请求调⽤HandlerMapping处理器映射器。
1.3、处理器映射器根据请求url找到具体的处理器,⽣成处理对象及处理器拦截器(如果有则⽣成)⼀并返回给DispatcherServlet 1.4、DispatcherServlet通过HandlerAdapter处理器适配器调⽤处理器1.5、执⾏处理器(Controller,也叫后端控制器)1.6、Controller执⾏完成返回ModelAndView1.7、HandlerAdapter将controller执⾏结果ModelAndView返回给DispaServlet1.8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器1.9、ViewReslover解析后返回具体View1.10、DispatcherServlet对View进⾏渲染视图(即将模型数据填充视图中)1.11、DispatcherServlet响应⽤户2、常⽤注解2.1、@Controller ⽤于定义控制器类2.2、@ResponseBody 表⽰⽅法的返回结果直接写⼊HTTP response body中2.3、@PathVariable 获取路径参数2.4、@RequestParam ⽤在⽅法的参数前⾯2.5、@RequestBody 返回JSON格式2.6、@RestController 是@Controller和@ResponseBody的合集2.7、@RequestMapping 提供理由信息,负责URL到Controller中的具体函数2.8、@ControllerAdvice 统⼀处理异常3、servlet⽣命周期3.1、加载和实例化3.2、初始化3.3、请求处理3.4、服务终⽌四、AOP1、基本概念1.1、核⼼业务功能和切⾯功能分别独⽴进⾏开发,然后把切⾯功能和核⼼业务功能“编织”在⼀起,这就叫AOP1.2、让关注点代码与业务代码分离1.3、⾯向切⾯编程就是指:对很多功能都有的重复代码抽取,再运⾏的时候往业务⽅法上动态注⼊“切⾯类代码”1.4、应⽤场景:⽇志、事务管理、权限控制2、实现原理2.1、jdk动态代理2.1.1、主要通过Proxy.newProxyInstance()和InvocationHandler这两个类和⽅法实现2.1.2、实现过程①、创建代理类proxy实现Invocation接⼝,重写invoke()⽅法:调⽤被代理类⽅法时默认调⽤此⽅法②、将被代理类作为构造函数的参数传⼊代理类proxy③、调⽤Proxy.newProxyInsatnce(classloader,interfaces,handler)⽅法⽣成代理类。
Spring学习笔记
Spring笔记SPRING笔记 (1)第一章SPRING简介 (3)一、S PRING是什么? (3)1、Spring是一个开源的用于简化采用Java语言开发企业级程序的一个分层的框架 (3)2、分层结构: (3)3、Spring源代码是公开的,但是非标准的 (4)二、S PRING的优点 (4)1、采用J2EE开发存在的问题: (4)2、为什么要使用Spring (4)三、S PRING的组成 (5)第二章SPRING的IOC (5)一、I O C的概念 (5)二、I O C的分类 (6)三、装配介绍 (6)1、Spring容器 (6)2、Spring开发要用到的JAR文件 (7)四、基本装配 (7)1、set方式注入 (7)1)注入简单属性(String和8中基本类型) (7)2)注入对象 (9)3)注入集合类型 (9)2、构造器方式装配(constructor注入) (11)3、比较set和构造注入方式 (11)五、复杂装配 (11)1、工厂方式装配 (11)1)静态工厂方式装配 (11)2)实例工厂方式装配 (12)2、自动装配(Autowring Properties) (12)3、bean的定义的继承 (13)4、bean的依赖关系检查 (13)5、scope (14)六、B EAN的生命周期 (14)1、步骤 (14)2、接口介绍 (15)七、事件处理 (16)1、事件监听原理 (16)2、编程步骤 (16)第三章SPRING的AOP (17)一、AOP的概念 (17)1、什么是AOP (17)2、AOP编程的好处 (17)二、AOP相关概念 (17)三、AOP基本原理 (18)四、S PRING的通知(具体的业务逻辑) (18)1、Spring的通知类型 (18)五、切入点(P OINTCUT) (20)1、pointcut (20)接口Pointcut:org.springframework.aop.Pointcut (20)接口Classfilter:org.springframework.aop.ClassFilter (20)接口MethodMather:org.springframework.aop.MethodMatcher (21)接口Advisor:org.springframework.aop.PointcutAdvisor (21)2、预定义切入点 (22)1)静态切入点: (22)2)动态切入点: (24)3)切入点的交叉与合并: (24)4)Introduction(非重点,严重影响性能,慢5到10倍) (24)六、自动代理 (25)1、使用BeanNameAutoProxyCreator进行自动代理 (25)2、DefaultAdvisorAutoProxyCreator (25)第四章SPRING对持久层的支持 (26)一、S PRING对持久层支持采用的策略: (26)二、S PRING对JDBC的支持 (26)Step 1: 配置数据源 (26)方式一:采用Spring内置的数据源(测试用,性能不高) (26)方式二:采用开源数据库产品如DBCP (27)方式三:直接使用容器提供的数据源(如Tomcat,Weblogic,SunAppServer) (27)Step 2: 配置JdbcTemplate模板类(封装了绝大多数数据库操作) (28)Step 3: 配置DAO (28)Step 4: 配置Service (28)三、S PRING对H IBERNATE的支持 (28)Step1:配置数据源 (28)Step2:配置sessionfactory (28)Step3:配置DAO (29)第五章SPRING对事务的支持 (29)一、事务的概念 (29)二、S PRING的事务机制 (29)三、S PRING事务编程 (30)1、整体介绍 (30)2、Spring声明式事务的编程 (30)3、Spring中事务的使用 (32)四、S PRING事务与EJB事务 (33)第六章框架整合 (33)一、SSH (33)二、S PRING与S TRUTS整合 (34)1、前提: (34)2、加载Spring方式: (34)1)采用ContextLoaderListener来创建ApplicationContext: (34)2)采用ContextLoaderPlugIn来创建ApplicationContext (34)3、集成方案 (34)方案一:通过Spring的ActionSupport类 (34)方式二:通过Spring的DelegatingActionProxy类 (35)方式三:通过Spring的DelegatingRequestProcessor类 (35)三、关于S PRING与EJB (36)第一章Spring简介spring in actionspring 技术手册▲精通Spring2.x企业级开发陈雄华一、Spring是什么?1、Spring是一个开源的用于简化企业级开发的分层框架2、分层结构:接口接口表示层业务层持久层域层1)Presentation layer(表示层)(1) 表示逻辑(生成界面代码)(2) 接收请求(3) 处理业务层抛出的异常(4) 负责规则验证(数据格式,数据非空等)(5) 流程控制2)Service layer(服务层/业务层)(1) 封装业务逻辑处理,并且对外暴露接口(2) 负责事务,安全等服务以及数据访问逻辑3)Persistence layer(持久层)提供透明的数据访问和接口(1) 封装数据访问的逻辑,暴露接口(2) 提供方便的数据访问的方案(查询语言,API,映射机制等)4)Domain layer(域层)域层就是一堆实体的集合,包括实体的关系。
Spring使用笔记
Spring使用笔记一、spring简介1、什么是springspring是一个高度灵活的轻量级框架,其目的降低程序的耦合度与复杂度,面向接口编程2、spring的作用a、管理对象、维护对象之间的关系(IOC)spring的核心就是IOC容器,用来管理对象(创建、使用、回收),维护对象与对象之间的关系,从而大大降低了对象与对象之间的耦合度,便于团队开发b、处理通用性业务(AOP)spring提供了AOP编程思想,面向切面编程,可以把通用性业务提取出来,切入到任何面向对象的节点上c、整合第三方框架spring提供了一系列第三方框架的整合,可以整合struts、hibernate、mybati 等框架,降低了框架与框架之间的耦合度,降低了框架的使用难度二、IOC1、什么是IOCIOC全称:inversion of control 控制反转是一种编程思想(开发模式),用来管理对象的创建、使用、回收,并且维护对象与对象之间的关系,IOC解决了对象与对象之间解耦,使得我们面向接口编程2、搭建环境a、把spring相关jar包导入到项目中b、把spring配置文件applicationContext.xml放入到项目中的classPath路径c、把log4j.properties配置文件放入到项目中的classPath路径d、创建一个JavaBeane、在applicationContext.xml中,把JavaBean配置到IOC容器中<bean name="自定义名称" class="类的完整路径"></bean>f、编写springAPI获取JavaBean对象,代码如下:ClassPathXmlApplicationContext ac = newClassPathXmlApplicationContext("applicationContext.xml");Person p = (Person)ac.getBean("person");p.setName("李宇春");System.out.println(p.getName());ac.close();3、依赖注入a、什么是DI(依赖注入)DI全称:Dependency Injection 依赖注入对象与对象之间的依赖关系,通过配置文件注入到IOC容器中,依赖注入指的就是对象与对象之间的关系b、注入方式*****set方法构造方法静态工厂实例工厂*****4、spring IOC的工作原理IOC底层实现了一个工厂模式,通过读取applicationContext.xml配置文件中的<bean>标签,把<bean>标签class属性指向的类注入到IOC容器,通过set方法或构造方法进行依赖注入对象与对象之间的关系,产生一个BeanFactory,BeanFactory通过getBean方法获取对象*****5、IOC管理对象的特点a、对象的创建方式在spring配置文件中,<bean>标签通过scope属性定义对象的创建方式,具体如下:scope="singleton" 默认方式,采用单例模式scope="prototype" 采用原型模式,对象是多例的scope="request" 在web中request范围scope="session" 在web中session范围scope="global session" 在web中application范围b、创建对象的时机单例:单例对象是在IOC容器创建时被创建多例:多例对象是对象被使用到时被创建,BeanFactory执行getBean方法被创建c、单例对象延迟加载<bean>标签通过设置lazy-init="true",可以使单例对象第一次使用时被创建,当scope="prototype"时,lazy-init="true"会失效d、对象的初始化方法与销毁方法init-method="方法名" 此方法在创建对象完毕之后被调用destroy-method="方法名" 此方法在对象回收之前被调用三、AOP1、什么是AOPAOP全称:Aspect Oriented Programming(面向切面/方面编程)AOP是一种编程思想(开发模式),是基于OOP基础之上更高级的一种编程思想,把一系列通用性功能提取出来,切入到任何一个OOP的组件上把功能性代码与业务流程代码分离,通过配置文件进行切入,对业务流程代码无侵入性,实现可配置编程2、AOP组成部分a、切面组件(aspect)功能代码,起始就是JavaBeanb、切入点(pointcut)指的是切面组件切入到哪个位置上,这个位置指的是包的路径,比如:控制层、service层、dao层c、通知类型切面组件在切入点之前还是之后切入前置通知:<aop:before>后置通知:<aop:after-returning>环绕通知:<aop:around>最终通知:<aop:after>异常通知:<aop:after-throwing>try{前置通知环绕通知前置部分目标方法//比如:personService.add();环绕通知后置部分后置通知}catch(Exception e) {异常通知}finally {最终通知}。
spring常用知识点总结
spring常用知识点总结Spring框架是一个轻量级的、基于Java的企业级应用开发框架,它提供了一种综合的基础设施,以便开发大型企业应用。
它是一个开源的框架,可以用于构建简单的Java SE应用程序,也可以构建复杂的企业级Java EE应用程序。
Spring框架通过依赖注入和面向切面编程,可以使得应用开发变得更加简单、灵活和高效。
本文将总结Spring框架的一些常用知识点,以便于开发者更好地理解和使用Spring框架。
1. Spring IoC容器IoC(Inversion of Control,控制反转)是Spring框架的核心,它负责管理各个组件之间的依赖关系,将对象的创建、销毁和依赖注入的工作交给容器来处理。
Spring IoC容器有两种实现方式:BeanFactory和ApplicationContext。
BeanFactory是IoC容器的基础接口,它提供了对Spring bean的基本功能支持。
ApplicationContext是BeanFactory的子接口,它提供了更多的实用功能,如事件传播、国际化、资源管理等。
开发者可以根据实际需要选择适合自己的IoC容器实现。
2. Spring Bean在Spring框架中,Bean是指由IoC容器管理的对象。
在Spring中,Bean是通过一个配置文件来描述的,这个配置文件可以是XML格式的,也可以是Java配置类。
Bean的配置信息包括Bean的id、class、作用域、依赖关系等。
Spring框架提供了一系列注解和标签用于描述Bean的配置信息,开发者可以根据实际情况选择合适的配置方式。
3. Spring依赖注入依赖注入是Spring框架的另一个核心特性,它通过将对象的依赖关系交给容器来管理,从而降低了组件之间的耦合度。
Spring框架提供了多种依赖注入方式,包括构造函数注入、setter注入、字段注入等。
开发者可以根据自己的习惯和实际需求选择合适的依赖注入方式。
Spring笔记——将spring进行到底DOC
chapter01 Spring简介一、Spring是什么?业务层框架的动机--快速构建Java 企业应用,框架简化开发过程,提供公共服务和便利的工具1)使组件松散耦合,组件依赖可配置2)提供公共服务:比如事务、安全3)简化使用j2ee 的技术在了解Spring之前,我们来了解在Java EE框架下企业级开发采用EJB框架的一些不足:(1) EJB太笨重,而且Entity EJB不能脱离容器(2) 企业级服务使用困难(3) 开发的复杂度太高(4) 侵入式方案,EJB要使用特定的接口因此,Spring应运而生。
3 Spring 的3个核心特性IOC --- Inverse of control使得业务组件都处在框架的管理之下框架可以管理组件的创建和依赖关系框架可以提供可以配置的服务AOPAspect Oreinted Programming在不修改组件的前提下,为组件提供扩展的服务简化对j2ee技术的使用更方便的使用j2ee 的技术jdbc / orm / strutsSpring是一个开源的用于简化采用Java语言开发企业级程序的一个分层的框架。
关于程序的分层结构:1、Presentation layer(表示层)(1) 表示逻辑(生成界面代码)(2) 接收请求(3) 处理业务层抛出的异常(4) 负责规则验证(数据格式,数据非空等)(5) 流程控制2、Service layer(服务层/业务层)(1) 封装业务逻辑处理,并且对外暴露接口(2) 负责事务,安全等服务3、Persistence layer(持久层)(1) 封装数据访问的逻辑,暴露接口(2) 提供方便的数据访问的方案(查询语言,API,映射机制等)Domain layer(域层)(1) 业务对象以及业务关系的表示(2) 处理简单的业务逻辑(3) 域层的对象可以穿越表示层,业务层,持久层二、Spring的作用为什么要使用Spring?(1) 简化企业级开发①封装了大部分的企业级服务,提供了更好的访问这些服务的方式②提供了IOC,AOP功能的容器,方便编程(2) 遵循Spring框架的应用程序,一定是设计良好的,针对接口编程,这样就简化了企业级程序的设计。
spring框架案例学习文档笔记
目录第一课:面向抽象编程 ....................................................................................... 3 第二课:Jdom 的基本使用 ..................................................................................... 3 第三课:模拟Spring 功能 .................................................................................... 4 第四课:搭建sping 的运行环境 . (7)一、 建立一个新的项目 ............................................................................. 7 二、 建立spring 的配置文件 ......................................................................... 7 三、 引入spring 的jar 包........................................................................... 7 四、 测试代码: ................................................................................... 7 五、 注意接口的使用: ............................................................................. 7 第五课:IOC(DI)配置及应用 . (8)一、 什么是IOC 、DI ................................................................................ 8 二、 编辑xml 文件时,没有提示 ...................................................................... 8 三、注入类型(Injecting dependencies) (8)(一) setter 注入类型Setter Injection .......................................................... 8 (二) 构造方法Constructor Injection (9)四、 id 、name .................................................................................... 10 五、 简单属性的注入 .............................................................................. 10 六、 Bean 的作用范围scope ......................................................................... 11 七、 集合注入 .................................................................................... 11 八、自动装配autowire (12)(一) byName .................................................................................. 12 (二) byType .................................................................................. 13 (三) 注意 .................................................................................... 13 九、生命周期 (14)(一) lazy-init/default-lazy-init ............................................................. 14 (二) init-method destroy-method 不要和prototype 一起用(了解) . (14)第六课:annotation 方式Spring (15)一、 开始使用annotation 配置Spring ............................................................... 15 二、@Autowired 、@Qualifier (15)(一) @Autowired .............................................................................. 15 (二) @Qualifier .............................................................................. 16 三、@Resource(重要、推荐) (16)(一) JSR-250 ................................................................................. 16 (二) @Resource . (16)四、 @Componet ................................................................................... 17 五、 @Scope 、@PostConstruct 、@PreDestroy .......................................................... 18 六、注解对应的jar 包 (18)第七课:AOP(面向切面编程) ..........................一、 AOP 概念 .............................二、 利用动态代理实现面向切面编程 19第八课:Spring AOP 配置选项 ........................一、 AOP 配置annotation 方式 ..............(一) 搭建annotation 开发环境 20(二)aspectJ 类库 .....................(三) AOP 的annotation 实例 ............(四)AspectJ 的专业术语 ...............Spring –SSH 整合 学习笔记---wjt276[2010-05-14](五) 织入点语法 (22)(六) Advice (23)(七) Pointcut (25)(八) annotatin方式的AOP实例 (25)二、AOP配置xml方式 (26)三、AOP实现动态代理注意 (27)第九课:DataSource (27)一、Sping配置数据源: (27)二、注入使用 (28)三、dbcp.BasicDataSource (28)第十课 Spring整合Hiberante3 (29)一、Spring配置hibernate3的SessionFactory (29)(一) xml形式的SessionFactory (29)(二) annotation注解方式的SessionFactory (29)二、引入hibernate所需要使用的jar (30)(一) 基本jar (30)(二) 加入annotation功能的jar包 (30)(三) 搭建日志环境并配置显示DDL语句jar包 (30)三、Spring整合hibernate3事务 (30)(一) Annotation注解方式配置事务管理 (30)(二) Spring事务选项 (34)(三) XML文件形式配置Spring事务管理 (36)四、HibernateTemplate (37)(一) HibernateTemplate (37)(二) HibernateDaoSupport (38)第十一课:Spring整合-SSH (39)一、第一步:加入jar包(需要的jar包列表) (39)二、第二步:首先整合Spring + Hibernate (40)三、第三步:再来整合Struts2 (40)四、struts的读常量: (42)第十二课:DTO、VO (42)一、DTO (42)二、VO (42)第十二课:SSH整合存在的问题 (42)一、Jsp中访问Session时,Session已经关闭 (42)二、如果不配置事务,openSessionView出现异常 (43)三、中文乱码问题: (43)第十三课:SSH整合的jar包 (44)一、Struts2 (44)二、Hibernate3.3.2 (44)三、Spring (45)第一课:面向抽象编程原来什么类都是写死的,现在是先建立一个大的标准,然后再各个实体类来实现他们的功能,然后在调用的时候,使用这个标准调用,这样,你们那个来都可以被调用。
Spring知识点最全笔记
说明笔记中每个知识点均标有如下标识中的一个或多个,释义如下:理解要求:了解:了解本知识点,明确本知识点的作用理解:理解本知识点所涉及内容的工作原理操作要求:操作:根据本知识点所涉及的内容,进行课堂案例的制作应用:根据本知识点所涉及的内容,进行融会贯通,灵活应用知识点相关:重点:本知识点为本课程重点内容难点:本知识点为本课程难点内容,理解难度较高(难点不一定是重点)目录spring简介【了解】 (3)资源包整理【了解】【应用】 (4)IoC【理解】【应用】【重点】 (5)DI【理解】【应用】【重点】 (7)BeanFactory【了解】 (8)Bean配置(XML)【理解】【应用】【重点】 (9)团队开发【了解】【操作】 (13)Bean配置(注解)【了解】【操作】 (14)Spring整合JUnit【了解】【操作】 (16)AOP简介【理解】【重点】 (17)AOP简介【理解】【重点】 (17)AOP基本概念【理解】【重点】 (18)AOP(XML)【理解】【应用】【重点】 (19)AOP(注解)【理解】【应用】【重点】 (24)CGLIB【理解】【难点】 (25)DAO模板类【了解】 (26)DAO支持抽象类【理解】【操作】 (29)事务管理基本概念【了解】 (31)声明式事务(XML)【理解】【重点】 (34)声明式事务(注解)【理解】【应用】【重点】 (36)SSH整合(XML)【理解】【应用】【重点】 (37)Hibernate模板类【理解】【应用】【重点】 (42)spring简介【了解】1.Spring是一个基于Java的轻量级的J2EE框架基于Java: 底层Java实现轻量级:性能较高,运行速度较快,内存消耗较少重量级组件:EJB、CGIJ2EE应用框架:Spring可以在JEE开发的三层架构的每一层为开发者带来帮助表现层:Servlet/JSP,Struts2,SpringMVC业务层:Bean管理、AOP、事务管理数据层:JDBC,Hibernate,Spring JDBCTemplate域模型层:实体类+DAO服务层:远端调用(webservice)[类似技术RMI+JNDI]Spring提供的每层的服务技术表现层:String MVC业务逻辑层:Bean管理、AOP、事务管理数据层:DAO支持抽象类,DAO模板技术JDBCTemplate2. Spring的发展历程创始人:Rod JohnsonExpert One-to-One J2EE Design and Development(2002)阐述了J2EE使用EJB开发设计的优点及解决方案Expert One-to-One J2EE Development without EJB(2004)阐述了J2EE开发过程中不使用EJB的解决方式(Spring雏形)3.Spring核心技术IOC:控制反转AOP:面向切面编程/面向方面编程4.Spring是一个超级的“黏合平台”,将很多技术黏合在一起,形成一个整体,使每个组件发挥其最大功效资源包整理【了解】【应用】1.本课程基于Spring3.2.0进行讲解2.下载地址:/release/org/springframework/spring/说明:通过Maven部署资源从仓库获取(后期课程)3.资源文件Spring资源包下spring-framework-3.2.0.RELEASE-dist.zipSpring依赖资源包spring-framework-3.0.2.RELEASE-dependencies.zip4.资源包目录层次结构docs:API帮助文档与官方手册libs:开发使用的jar包schema:开发使用的XML约束文档源文件5.开发jar包核心jar(4个)spring-beans-3.2.0.RELEASE.jarspring-context-3.2.0.RELEASE.jarspring-core-3.2.0.RELEASE.jarspring-expression-3.2.0.RELEASE.jar日志相关jar(2个)commons-logging-1.1.1.jarcommons-logging日志整合,与slf4j类似,由apache提供log4j-1.2.15.jarIoC【理解】【应用】【重点】1.IoC(Inversion of Control)控制反转A:控制:控制的双方是什么?谁控制谁?主控方:Spring被控方:应用程序所使用的资源(原始)应用程序控制自己执行操作需要使用的外部资源(Spring)Spring控制整个程序中所需要使用的外部资源B.反转:什么是反转?反转什么?正向:应用程序直接调用资源反向:应用程序依赖Spring为其提供资源反转的是资源的控制权应用程序由主动调用资源,变为被动的等待Spring提供资源C.有什么好处?正向缺点:应用程序控制的资源分布在程序的每一个地方反向的优点:所有的资源都在Spring中,便于管理总结:Spring反向控制应用程序所需要使用的外部资源。
Spring学习笔记
Spring串讲一、Spring的基本内容1.什么是Spring:是一个用来简化企业级程序开发的分层的框架。
它旨在分离体系结构的层次,因此每一层都可以修改而不会影响到其它层。
层与层之间的依赖通常是以接口的形式表现,以确保其耦合尽可能松散。
2.Spring的组成(7个模块):(1)SpringCore:Spring的核心容器,主要提供了组件的创建、装配、销毁的基本功能。
(2)SpringContext:Spring上下文,基于Spring核心容器,扩展了核心容器,主要提供了事件处理、国际化等功能。
(3)SpringAOP:提供了AOP编程的支持。
(4)SpringDAO:提供了JDBC的支持、一种实现编程性和声明性的事务管理方法。
(5)SpringORM:提供了对O/R mapping的支持,对Hibernate、JDBC等的再次封装。
(6)SpringWeb:基于Spring上下文的,提供了webApplication的容器,方便web的集成。
(7)SpringWebMVC:提供了MVC的一个完整的实现。
二、Spring的核心内容1.IOC (Inversion of control): 控制反转/依赖注入(1)IOC的概念:控制反转/依赖注入,组件之间的依赖关系由容器在运行时决定1)组件:JavaBean2)依赖关系:调用/包含3)容器:Spring4)控制权由对象本身转向容器;由容器根据配置文件去创建实例并创建各个实例之间的依赖关系(2)IOC的优点:1)代码的耦合度低2)代码的维护性好3)代码量少(3)IOC的核心--- BeanFactory1)BeanFactory是所有容器的父接口,它提供了基本的对象的装配的支持2)XmlBeanFactory是他最常用的实现之一。
3)在Spring中,BeanFactory创建的各个实例称作Bean4)BeanFactory只有在客户端调用时才实例化对象,即调用getBean()时容器才会创建对应的组件的实例,在默认情况下返回的对象采用单例模式。
Spring5学习笔记
Spring5学习笔记Spring5学习笔记Spring jav a笔记⾝逐沧浪⽔,冷眼观世间⼀、为什么要学习Spring?Spring的优点1、Spring 是轻量级的开源的 JavaEE 框架2、Spring 可以解决企业应⽤开发的复杂性3、Spring 有两个核⼼部分:IOC 和 Aop(1) IOC:控制反转,把创建对象过程交给 Spring 进⾏管理(2) Aop:⾯向切⾯,不修改源代码进⾏功能增强4、Spring 特点(1)⽅便解耦,简化开发(2)Aop 编程⽀持(3)⽅便程序测试(4)⽅便和其他框架进⾏整合(5)⽅便进⾏事务操作(6)降低 API 开发难度⼆、IOC(概念和原理)1、什么是 IOC(1)控制反转,把对象创建和对象之间的调⽤过程,交给 Spring 进⾏管理(2)使⽤ IOC ⽬的:为了耦合度降低2、IOC 底层原理(1)xml 解析、⼯⼚模式、反射3、画图讲解 IOC 底层原理1. I OC (B e anF actor y 接⼝)1、IOC 思想基于 IOC 容器完成,IOC 容器底层就是对象⼯⼚2、Spring 提供 IOC 容器实现两种⽅式:(两个接⼝)(1)BeanFactory:IOC 容器基本实现,是 Spring 内部的使⽤接⼝,不提供开发⼈员进⾏使⽤加载配置⽂件时候不会创建对象,在获取对象(使⽤)才去创建对象(2)ApplicationContext:BeanFactory 接⼝的⼦接⼝,提供更多更强⼤的功能,⼀般由开发⼈员进⾏使⽤加载配置⽂件时候就会把在配置⽂件对象进⾏创建3、ApplicationContext 接⼝有实现类2. I OC 操作 B e an 管理(概念)1、什么是 Bean 管理(0) Bean 管理指的是两个操作(1) Spring 创建对象(2) Spirng 注⼊属性2、Bean 管理操作有两种⽅式(1)基于 xml 配置⽂件⽅式实现(2)基于注解⽅式实现三、n 管理(基于 xml ⽅式)IOC 操作 Bea n 管理(基于 xm l ⽅式)1. 基于 x m l ⽅式创建对象(1)在 spring 配置⽂件中,使⽤ bean 标签,标签⾥⾯添加对应属性,就可以实现对象创建(2)在 bean 标签有很多属性,介绍常⽤的属性id 属性:唯⼀标识class 属性:类全路径(包类路径)(3)创建对象时候,默认也是执⾏⽆参数构造⽅法完成对象创建2、基于 xml ⽅式注⼊属性(1)DI:依赖注⼊,就是注⼊属性3、第⼀种注⼊⽅式:使⽤ set ⽅法进⾏注⼊(1)创建类,定义属性和对应的 set ⽅法enter description here/*** 演⽰使⽤ set ⽅法进⾏注⼊属性*/public class Book {//创建属性private String bname;private String bauthor;//创建属性对应的 set ⽅法public void setBname(String bname) {this.bname = bname;}public void setBauthor(String bauthor) {this.bauthor = bauthor;}}(2)在 spring 配置⽂件配置对象创建,配置属性注⼊<!--2 set ⽅法注⼊属性--><bean id="book" class="com.atguigu.spring5.Book"><!--使⽤ property 完成属性注⼊name:类⾥⾯属性名称value:向属性注⼊的值--><property name="bname" value="易筋经"></property><property name="bauthor" value="达摩⽼祖"></property></bean>2. 第⼆种注⼊⽅式:使⽤有参数构造进⾏注⼊(1)创建类,定义属性,创建属性对应有参数构造⽅法/*** 使⽤有参数构造注⼊*/public class Orders {//属性private String oname;private String address;//有参数构造public Orders(String oname,String address) {this.oname = oname;this.address = address;}}(2)在 spring 配置⽂件中进⾏配置<!--3 有参数构造注⼊属性--><bean id="orders" class="com.atguigu.spring5.Orders"><constructor-arg name="oname" value="电脑"></constructor-arg> <constructor-arg name="address" value="China"></constructor-arg> </bean>3. I OC 操作 B e an 管理(x m l 注⼊其他类型属性)1、字⾯量(1)null 值<!--null 值--><property name="address"><null/></property>(2)属性值包含特殊符号<!--属性值包含特殊符号1 把<>进⾏转义 < >2 把带特殊符号内容写到 CDATA--><property name="address"><value><![CDATA[<<南京>>]]></value></property>2、注⼊属性-外部 bean(1)创建两个类 service 类和 dao 类(2)在 service 调⽤ dao ⾥⾯的⽅法(3)在 spring 配置⽂件中进⾏配置public class UserService {//创建 UserDao 类型属性,⽣成 set ⽅法private UserDao userDao;public void setUserDao(UserDao userDao) {erDao = userDao;}public void add() {System.out.println("service add...............");userDao.update();}}<!--1 service 和 dao 对象创建--><bean id="userService" class="erService"><!--注⼊ userDao 对象name 属性:类⾥⾯属性名称ref 属性:创建 userDao 对象 bean 标签 id 值--><property name="userDao" ref="userDaoImpl"></property>3、注⼊属性-内部 bean(1)⼀对多关系:部门和员⼯⼀个部门有多个员⼯,⼀个员⼯属于⼀个部门部门是⼀,员⼯是多(2)在实体类之间表⽰⼀对多关系,员⼯表⽰所属部门,使⽤对象类型属性进⾏表⽰//部门类public class Dept {private String dname;public void setDname(String dname) {this.dname = dname;}}//员⼯类public class Emp {private String ename;private String gender;//员⼯属于某⼀个部门,使⽤对象形式表⽰private Dept dept;public void setDept(Dept dept) {this.dept = dept;}public void setEname(String ename) {this.ename = ename;}public void setGender(String gender) {this.gender = gender;}}(3)在 spring 配置⽂件中进⾏配置<!--内部 bean--><bean id="emp" class="com.atguigu.spring5.bean.Emp"><!--设置两个普通属性--><property name="ename" value="lucy"></property><property name="gender" value="⼥"></property><!--设置对象类型属性--><property name="dept"><bean id="dept" class="com.atguigu.spring5.bean.Dept"><property name="dname" value="安保部"></property></bean></property></bean>4、注⼊属性-级联赋值(1)第⼀种写法<!--级联赋值--><bean id="emp" class="com.atguigu.spring5.bean.Emp"><!--设置两个普通属性--><property name="ename" value="lucy"></property><property name="gender" value="⼥"></property><!--级联赋值--><property name="dept" ref="dept"></property></bean><bean id="dept" class="com.atguigu.spring5.bean.Dept"><property name="dname" value="财务部"></property></bean>(2)第⼆种写法<!--级联赋值--><bean id="emp" class="com.atguigu.spring5.bean.Emp"><!--设置两个普通属性--><property name="ename" value="lucy"></property><property name="gender" value="⼥"></property><!--级联赋值--><property name="dept" ref="dept"></property><property name="dept.dname" value="技术部"></property></bean><bean id="dept" class="com.atguigu.spring5.bean.Dept"><property name="dname" value="财务部"></property></bean>4. I OC 操作 B e an 管理(x m l 注⼊集合属性)1、注⼊数组类型属性2、注⼊ List 集合类型属性3、注⼊ Map 集合类型属性(1)创建类,定义数组、list、map、set 类型属性,⽣成对应 set ⽅法public class Stu {//1 数组类型属性private String[] courses;//2 list 集合类型属性private List<String> list;//3 map 集合类型属性private Map<String,String> maps;//4 set 集合类型属性private Set<String> sets;public void setSets(Set<String> sets) {this.sets = sets;}public void setCourses(String[] courses) {this.courses = courses;}public void setList(List<String> list) {this.list = list;}public void setMaps(Map<String, String> maps) {this.maps = maps;}}(2)在 spring 配置⽂件进⾏配置<!--1 集合类型属性注⼊--><bean id="stu" class="com.atguigu.spring5.collectiontype.Stu"><!--数组类型属性注⼊--><property name="courses"><array><value>java 课程</value><value>数据库课程</value></array></property><!--list 类型属性注⼊--><property name="list"><list><value>张三</value><value>⼩三</value></list></property><!--map 类型属性注⼊--><property name="maps"><map><entry key="JAVA" value="java"></entry><entry key="PHP" value="php"></entry></map></property><!--set 类型属性注⼊--><property name="sets"><set><value>MySQL</value><value>Redis</value></set></property></bean>4、在集合⾥⾯设置对象类型值<!--创建多个 course 对象--><bean id="course1" class="com.atguigu.spring5.collectiontype.Course"><property name="cname" value="Spring5 框架"></property></bean><bean id="course2" class="com.atguigu.spring5.collectiontype.Course"><property name="cname" value="MyBatis 框架"></property></bean><!--注⼊ list 集合类型,值是对象--><property name="courseList"></list></property>5、把集合注⼊部分提取出来(1)在 spring 配置⽂件中引⼊名称空间 util<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:util="/schema/util"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /schema/util /schema/util/spring-util.xsd">(2)使⽤ util 标签完成 list 集合注⼊提取<!--1 提取 list 集合类型属性注⼊--><util:list id="bookList"><value>易筋经</value><value>九阴真经</value><value>九阳神功</value></util:list><!--2 提取 list 集合类型属性注⼊使⽤--><bean id="book" class="com.atguigu.spring5.collectiontype.Book"><property name="list" ref="bookList"></property></bean>5. I OC 操作 B e an 管理(F actor yB e an)1、Spring 有两种类型 bean,⼀种普通 bean,另外⼀种⼯⼚ bean(FactoryBean)2、普通 bean:在配置⽂件中定义 bean 类型就是返回类型3、⼯⼚ bean:在配置⽂件定义 bean 类型可以和返回类型不⼀样第⼀步 创建类,让这个类作为⼯⼚ bean,实现接⼝ FactoryBean第⼆步 实现接⼝⾥⾯的⽅法,在实现的⽅法中定义返回的 bean 类型public class MyBean implements FactoryBean<Course> {//定义返回 bean@Overridepublic Course getObject() throws Exception {Course course = new Course();course.setCname("abc");return course;}@Overridepublic Class<?> getObjectType() {return null;}@Overridepublic boolean isSingleton() {return false;}}<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean"></bean>@Testpublic void test3() {ApplicationContext context =new ClassPathXmlApplicationContext("bean3.xml");Course course = context.getBean("myBean", Course.class);System.out.println(course);}6. I OC 操作 B e an 管理(b e an 作⽤域)1、在 Spring ⾥⾯,设置创建 bean 实例是单实例还是多实例2、在 Spring ⾥⾯,默认情况下,bean 是单实例对象6-1. 如何设置单实例还是多实例(1)在 spring 配置⽂件 bean 标签⾥⾯有属性(scope)⽤于设置单实例还是多实例(2) scope 属性值第⼀个值 默认值,singleton,表⽰是单实例对象第⼆个值 prototype,表⽰是多实例对象(3) singleton 和 prototype 区别第⼀ singleton 单实例,prototype 多实例第⼆ 设置 scope 值是 singleton 时候,加载 spring 配置⽂件时候就会创建单实例对象设置 scope 值是 prototype 时候,不是在加载 spring 配置⽂件时候创建 对象,在调⽤getBean ⽅法时候创建多实例对象7. I OC 操作 B e an 管理(b e an ⽣命周期)1、⽣命周期(1)从对象创建到对象销毁的过程2、bean ⽣命周期(1)通过构造器创建 bean 实例(⽆参数构造)(2)为 bean 的属性设置值和对其他 bean 引⽤(调⽤ set ⽅法)(3)调⽤ bean 的初始化的⽅法(需要进⾏配置初始化的⽅法)(4)bean 可以使⽤了(对象获取到了)(5)当容器关闭时候,调⽤ bean 的销毁的⽅法(需要进⾏配置销毁的⽅法)8. I OC 操作 B e an 管理(x m l ⾃动装配)1、什么是⾃动装配(1)根据指定装配规则(属性名称或者属性类型),Spring ⾃动将匹配的属性值进⾏注⼊2、演⽰⾃动装配过程(1)根据属性名称⾃动注⼊<!--实现⾃动装配bean 标签属性 autowire,配置⾃动装配autowire 属性常⽤两个值:byName 根据属性名称注⼊,注⼊值 bean 的 id 值和类属性名称⼀样byType 根据属性类型注⼊--><bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName"><!--<property name="dept" ref="dept"></property>--></bean><bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>(2)根据属性类型⾃动注⼊<!--实现⾃动装配bean 标签属性 autowire,配置⾃动装配autowire 属性常⽤两个值:byName 根据属性名称注⼊,注⼊值 bean 的 id 值和类属性名称⼀样byType 根据属性类型注⼊--><bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType"><!--<property name="dept" ref="dept"></property>--></bean><bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>9. I OC 操作 B e an 管理(外部属性⽂件)1、直接配置数据库信息(1)配置德鲁伊连接池(2)引⼊德鲁伊连接池依赖 jar 包2、引⼊外部属性⽂件配置数据库连接池(1)创建外部属性⽂件,properties 格式⽂件,写数据库信息(2)把外部 properties 属性⽂件引⼊到 spring 配置⽂件中引⼊ context 名称空间⚫ 在 spring 配置⽂件使⽤标签引⼊外部属性⽂件四、IOC 操作 Bea n 管理(基于注解⽅式)1、什么是注解(1)注解是代码特殊标记,格式:@注解名称(属性名称=属性值, 属性名称=属性值..)(2)使⽤注解,注解作⽤在类上⾯,⽅法上⾯,属性上⾯(3)使⽤注解⽬的:简化 xml 配置2、Spring 针对 Bean 管理中创建对象提供注解(1)@Component(2)@Service(3)@Controller (4)@Repository<!--直接配置连接池--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"></property ><property name="url" value="jdbc:mysql://localhost:3306/userDb"></property ><property name="username" value="root"></property ><property name="password" value="root"></property ></bean ><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:util="/schema/util"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /schema/util /schema/util/spring-util.xsd/schema/context /schema/context/spring-context.xsd"> <!--引⼊外部属性⽂件--><context:property-placeholder location="classpath:jdbc.properties"/><!--配置连接池--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${prop.driverClass}"></property ><property name="url" value="${prop.url}"></property ><property name="username" value="${erName}"></property ><property name="password" value="${prop.password}"></property ></bean >上⾯四个注解功能是⼀样的,都可以⽤来创建 bean 实例3、基于注解⽅式实现对象创建第⼀步 引⼊依赖第⼆步 开启组件扫描<!--开启组件扫描1 如果扫描多个包,多个包使⽤逗号隔开2 扫描包上层⽬录--><context:component-scan base-package="com.atguigu"></context:component-scan>第三步 创建类,在类上⾯添加创建对象注解//在注解⾥⾯ value 属性值可以省略不写,//默认值是类名称,⾸字母⼩写//UserService -- userService@Component(value = "userService") //<bean id="userService" class=".."/> public class UserService { public void add() {System.out.println("service add.......");}}4、开启组件扫描细节配置<!--⽰例 1use-default-filters="false" 表⽰现在不使⽤默认 filter,⾃⼰配置 filtercontext:include-filter ,设置扫描哪些内容--><context:component-scan base-package="com.atguigu" use-default- filters="false"><context:include-filter type="annotation"expression="org.springframework.stereotype.Controller"/></context:component-scan><!--⽰例 2下⾯配置扫描包所有内容context:exclude-filter:设置哪些内容不进⾏扫描--><context:component-scan base-package="com.atguigu"><context:exclude-filter type="annotation"expression="org.springframework.stereotype.Controller"/></context:component-scan>5、基于注解⽅式实现属性注⼊(1)@Autowired:根据属性类型进⾏⾃动装配第⼀步 把 service 和 dao 对象创建,在 service 和 dao 类添加创建对象注解第⼆步 在 service 注⼊ dao 对象,在 service 类添加 dao 类型属性,在属性上⾯使⽤注解@Servicepublic class UserService {//定义 dao 类型属性//不需要添加 set ⽅法//添加注⼊属性注解@Autowiredprivate UserDao userDao;public void add() {System.out.println("service add.......");userDao.add();}}(2)@Qualifier:根据名称进⾏注⼊这个@Qualifier 注解的使⽤,和上⾯@Autowired ⼀起使⽤//定义 dao 类型属性//不需要添加 set ⽅法//添加注⼊属性注解@Autowired//根据类型进⾏注⼊@Qualifier(value = "userDaoImpl1") //根据名称进⾏注⼊private UserDao userDao;(3)@Resource:可以根据类型注⼊,可以根据名称注⼊//@Resource //根据类型进⾏注⼊@Resource(name = "userDaoImpl1") //根据名称进⾏注⼊private UserDao userDao;(4)@Value:注⼊普通类型属性@Value(value = "abc") private String name;6、完全注解开发 (1)创建配置类,替代 xml 配置⽂件@Configuration//作为配置类,替代 xml 配置⽂件@ComponentScan(basePackages = {"com.atguigu"})public class SpringConfig {}(2)编写测试类@Testpublic void testService2() {//加载配置类ApplicationContext context= new AnnotationConfigApplicationContext(SpringConfig.class);UserService userService = context.getBean("userService", UserService.class);System.out.println(userService);userService.add();}五、AOP(概念)1、什么是 AOP(1)⾯向切⾯编程(⽅⾯),利⽤ AOP 可以对业务逻辑的各个部分进⾏隔离,从⽽使得业务逻辑各部分之间的耦合度降低,提⾼程序的可重⽤性,同时提⾼了开发的效率。
Spring笔记
Spring 学习笔记1.Spring的技术核心?。
Spring 是一个开源的:控制反转(Inversion of control )IOC ,依赖注入(Dependency Injection )和面向切面(Aop)的框架,它主要的目的是简化企业的开发。
2.控制反转?所谓控制反转就是:应用本身不负责依赖对象的创建与维护,依赖对象的创建与维护是有外部容器负责的。
这样控制权就有应用转向了外部容器,控制权的转移就是所谓的控制反转。
3.依赖注入?所谓依赖注入就是指:在运行期由外部容器动态的将依赖对象注入到组件中。
4 .为什么要使用Spring 呢?<a>可以降低组件之间的耦合度,实现软件各层之间的解耦;Control----→Service----→DAO<b>使用Spring 容器可以使用它提供的众多服务:事务管理服务,JMS服务,Spring Core服务,持久化服务,其它......事务管理:不需要手工控制事物<c>容器提供单利模式支持;<d>容器提供了AOP技术,利用它很容易实现如:权限拦截,运行期监控等功能。
<e>容器提供了很多的辅助类,使用这些类能够加快应用的开发,如:Jdbc Template,Hibernate Template 。
<f>Spring对主流的应用框架提供了支持如:Hibernate ,JPA , Struts.等。
4.实例化Spring 容器?两种方式A : 在类路径下寻找配置文件来实例化Spring容器。
ApplicationContext ctx = new ClassPathXmlApplicationContext(“config-path”);B:在文件系统路径下寻找配置文件来实例化Spring 容器;ApplicationContext ctx = new FileSystemXmlApplicationContext(“d:\\bean.xml”);注:第二种方式通常在本地测试时用,因为每个应用的配置在不同机器上会不同。
马士兵Spring课堂笔记(超级详细版)
课程内容---…详细包括整合struts hibernate------------------------------------1.面向接口(抽象)编程的概念与好处2.IOC/DI的概念与好处a)inversion of controlb)dependency injection3.AOP的概念与好处4.Spring简介5.Spring应用IOC/DI(重要)a)xmlb)annotation6.Spring应用AOP(重要)a)xmlb)annotation7.Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合(重要)a)opensessionInviewfilter(记住,解决什么问题,怎么解决)8.Spring JDBC面向接口编程…(面向抽象编程)1.场景:用户添加2.Spring_0100_AbstractOrientedProgramminga)不是AOP:Aspect Oriented Programming3.好处:灵活什么是IOC(DI),,,有什么好处1.把自己new的东西改为由容器提供a)初始化具体值b)装配<?xml version="1.0"?>-<beans><bean class="erDAOImpl" id="u"/>(class 是个类。
Id就等于构造了一个对象)<bean class="erService" id="userService"><property bean="u" name="userDAO"/> </bean>(把u这个对象注入到UserService这个类的一个userDAO的一个属性里)-</beans>2.好处:灵活装配Spring简介包括整合struts hibernate------------------------------------1.项目名称:Spring_0200_IOC_Introduction2.环境搭建a)只用IOCi.spring.jar , jarkata-commons/commons-loggin.jar3.IOC容器a)实例化具体beanb)动态装配4.AOP支持a)安全检查b)管理transactionSpring IOC配置与应用1.FAQ:不给提示:a)window – preferences – myeclipse – xml – xml catalogb)User Specified Entries – addi.Location: D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\spring-beans-2.5.xsdii.URI:file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resources/spring-beans-2.5.xsd iii.Key Type: Schema Locationiv.Key: /schema/beans/spring-beans-2.5.xsd2.注入类型a)Spring_0300_IOC_Injection_Typeb)setter(重要)c)构造方法(可以忘记)d)接口注入(可以忘记)3.id vs. Name(可以把Id换成name,没什么区别!)a)Spring_0400_IOC_Id_Nameb)name可以用特殊字符4.简单属性的注入a)Spring_0500_IOC_SimplePropertyb)<property name=… value=….>在配置文件里直接赋值!(在此简单属性为int和string,会自动转换)5.<bean 中的scope属性a)Spring_0600_IOC_Bean_Scopeb)singleton 单例(无论去多少次都是同一个bean)c)proptotype 每次创建新的对象6.集合注入a)Spring_0700_IOC_Collectionsb)很少用,不重要!参考程序7.自动装配a)Spring_0800_IOC_AutoWireb)byNamec)byTyped)如果所有的bean都用同一种,可以使用beans的属性:default-autowire-<bean class="erDAOImpl" name="userDAO"><property name="daoId" value="1"/> </bean><bean class="erDAOImpl" name="userDAO2"><property name="daoId" value="2"/> </bean><bean class="erService"autowire="byType" scope="prototype" id="userService"></bean> </beans>(这里会报错,因为有两个userDAO和UserDAO2都是int类型!)(如果说byname则会显示第一个的内容“1”!,因为UserService类里面的userDAO属性与第一个的名字一样!)8.生命周期a)Spring_0900_IOC_Life_Cycleb)lazy-init (不重要)c)init-method与destroy-methd 不要和prototype一起用(了解)<bean class="erDAOImpl" id="u"></bean><bean class="erService" id="userService" scope="prototype"destroy-method="destroy" init-method="init"></bean></beans>9.Annotation第一步:a)修改xml文件,参考文档<context:annotation-config />b)默认按类型by typec)如果想用byName,使用@Qulifierd)写在private field(第三种注入形式)(不建议,破坏封装)e)如果写在set上,@qualifier需要写在参数上f)10.@Resource(重要)a)加入:j2ee/common-annotations.jarb)默认按名称,名称找不到,按类型c)可以指定特定名称d)推荐使用e)不足:如果没有源码,就无法运用annotation,只能使用xml11.@Component@Service @Controller @Repository(四个一样的功能!!)a)初始化的名字默认为类名首字母小写b)可以指定初始化bean的名字首先先加载ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); 即读beans.xml里面的内容,然后通过找从com.bjsxt开始“scan”含@component的类,找到之后就初始化对象,结果在其一个属相的set方法上找到一个源为“u”的一个bean,于是就加载那个bean!12.@Scope13.@PostConstruct = init-method;(在构造对象后执行此方法)@PreDestroy = destroy-method;(在容器销毁前执行此方法)什么是AOP1.面向切面编程Aspect-Oriented-Programminga)是对面向对象的思维方式的有力补充2.Spring_1400_AOP_Introduction3.好处:可以动态的添加和删除在切面上的逻辑而不影响原来的执行代码a)Filterb)Struts2的interceptor4.概念:a)JoinPoint 释意:切面与原方法交接点即切入点b)PointCut 释意:切入点集合是com.xyz.someapp.service.下面的任何类,任何方法,任何返回值的一个切入点的集合。
spring学习笔记
Spring课程1 Spring基本特征Spring是一个非常活跃的开源框架;它是一个基于Core来构架多层JavaEE系统的框架,它的主要目地是简化企业开发.Spring以一种非侵入式的方式来管理你的代码,Spring提倡”最少侵入”,这也就意味着你可以适当的时候安装或卸载Spring2 Spring的组成2.1 Spring的jar包到/download下载spring,然后进行解压缩,在解压目录中找到下面jar文件,拷贝到类路径下--spring的核心类库在spring文档的dist下dist\spring.jar--引入的第三方类库都spring文档的lib下lib\jakarta-commons\commons-logging.jar如果使用了切面编程(AOP),还需要下列jar文件lib/aspectj/aspectjweaver.jar和aspectjrt.jarlib/cglib/cglib-nodep-2.1_3.jar如果使用了JSR-250中的注解,如@Resource/@PostConstruct/@PreDestroy,还需要下列jar文件lib\j2ee\common-annotations.jar注:JSR(Java 规范请求)是指向JCP(Java Community Process)提出新增一个标准化技术规范的正式请求。
任何人都可以提交JSR(Java 规范请求),以向Java 平台增添新的API和服务。
JSR已成为Java界的一个重要标准2.2 Spring配置文件默认情况下是applicationContext.xml文件。
可以建立很多xml文件,工程中一般都是这样配置的。
2.3 Spring API3 Spring基本功能详解3.1 SpringIOCSpring的控制反转:把对象的创建、初始化、销毁等工作交给spring容器来做。
由spring容器控制对象的生命周期。
最全面的Spring学习笔记
最全⾯的Spring学习笔记致⼒于提供⼀种⽅法管理你的业务对象。
在⼤量Java EE的应⽤中,随处可见Spring。
今天我将简单的介绍⼀下Spring这个框架。
本⽂适合读者:想学Spring的Java开发者刚⽤Spring不久的⼈Why为什么要使⽤Spring?Spring主要两个有功能为我们的业务对象管理提供了⾮常便捷的⽅法:DI(Dependency Injection,依赖注⼊)AOP(Aspect Oriented Programming,⾯向切⾯编程)Java Bean每⼀个类实现了Bean的规范才可以由Spring来接管,那么Bean的规范是什么呢?必须是个公有(public)类有⽆参构造函数⽤公共⽅法暴露内部成员属性(getter,setter)实现这样规范的类,被称为Java Bean。
即是⼀种可重⽤的组件。
DI-依赖注⼊简单来说,⼀个系统中可能会有成千上万个对象。
如果要⼿⼯维护它们之间的关系,这是不可想象的。
我们可以在Spring的XML⽂件描述它们之间的关系,由Spring⾃动来注⼊它们——⽐如A类的实例需要B类的实例作为参数set进去。
AOP-⾯向切⾯编程就以⽇志系统为例。
在执⾏某个操作前后都需要输出⽇志,如果⼿⼯加代码,那简直太可怕了。
⽽且等代码庞⼤起来,也是⾮常难维护的⼀种情况。
这⾥就需要⾯向切⾯来编程How关于BeanBean的⽣命周期如你所见,在bean准备就绪之前,bean⼯⼚执⾏了若⼲启动步骤。
我们对图进⾏详细描述:1. Spring对bean进⾏实例化;2. Spring将值和bean的引⽤注⼊到bean对应的属性中;3. 如果bean实现了BeanNameAware接⼝,Spring将bean的ID传递给setBean-Name()⽅法;4. 如果bean实现了BeanFactoryAware接⼝,Spring将调⽤setBeanFactory()⽅法,将BeanFactory容器实例传⼊;5. 如果bean实现了ApplicationContextAware接⼝,Spring将调⽤setApplicationContext()⽅法,将bean所在的应⽤上下⽂的引⽤传⼊进来;6. 如果bean实现了BeanPostProcessor接⼝,Spring将调⽤它们的post-ProcessBeforeInitialization()⽅法;7. 如果bean实现了InitializingBean接⼝,Spring将调⽤它们的after-PropertiesSet()⽅法。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
AnnotationConfigApplicationContext生成IOC容器:
public static void main(String[] arg){
ApplicationContext context=new AnnotationConfigApplicationContext(PojoConfig.class);
p:id="1" p:userName="role_name_1" p:note="user_note_1" />
<bean id="user2" class="er"
p:id="2" p:userName="role_name_2" p:note="user_note_2" />
<value>value-array-2</value>
<value>value-array-3</value>
</array>
</property>
</bean>
2.4 命名空间装配:
<!-- 头部必须有c,p,util这两部分 -->
<beans xmlns="/schema/beans"
/schema/context
/schema/context/spring-context-4.0.xsd">
</beans>
2.2 装配代码
<entry key-ref="role2" value-ref="user2" />
</util:map>
<util:set id="set">
<ref bean="role1" />
<ref bean="role2" />
</util:set>
<property name="list">
<list>
<!-- 单一个值 -->
<value>value-list-1</value>
<!-- 如果是一个类 -->
<ref bean="javabean的ID"/>
</list>
<prop key="prop3">value-prop-3</prop>
</props&perty name="set">
<set>
<!-- 单一个值 -->
<value>value-set-1</value>
<util:list id="list">
<ref bean="role1" />
<ref bean="role2" />
</util:list>
<util:map id="map">
<entry key-ref="role1" value-ref="user1" />
1. 三种注入方式
1.1 构造器注入:
<bean id="" class="包名.类名">
<constructor-arg index="0" value="xxx">
...
</bean>
有参数构造,第一个参数(index按照顺序来)是:xxx。调用该javabean的名称为:id里面的
<!-- 引用其他的bean -->
<bean id="" class="">
<property name="参数名" ref="其他bean的ID">
</bean>
2.3 装配集合(举例,包括:list、map、props、set、array)
<bean id="complexAssembly" class="plexAssembly">
可以配置属性或者方法上,或者参数中!
3.3.1 举例:
接口:
public interface RoleService2{
public void printRoleInfo();
}
实现类:
@component
public class RoleServiceImpl2 implements RoleService2{
<bean id="userRoleAssembly" class="com.ssm.chapter10.pojo. UserRoleAssembly"
p:id="1" p:list-ref="list" p:map-ref="map" p:set-ref="set" />
</beans>
xmlns:context="/schema/context"
xsi:schemaLocation="/schema/beans
/schema/beans/spring-beans-4.0.xsd
</property>
<property name="map">
<map>
<!-- 单一个值 -->
<entry key="key1" value="value-key-1" />
<!-- 如果是一个类 -->
<entry key-ref="key1" value-ref="javabean的ID" />
<bean id="role2" class="com.ssm.chapter10.pojo.Role"
p:id="2" p:roleName="role_name_2" p:note="role_note_2" />
<bean id="user1" class="er"
@ComponentScan(basePackagesClasses={xxx.class,xxx.class}) //配置项:basePackages、basePackageClasses;
@ComponentScan(basePackages={xxx.xxxx.xxx.xxx)
public class PojoConfig{
2.1 头文件:
<?xml version='1.0' encoding='UTF-8' ?>
<beans xmlns="/schema/beans"
xmlns:xsi="/2001/XMLSchema-instance" xmlns:p="/schema/p"
<!-- 如果是一个类 -->
<ref bean="javabean的ID"/>
</set>
</property>
<property name="array">
<array>
<value>value-array-1</value>
<bean id="" class="包名.类名">
<property name="参数名称" value="参数值">
...
<property name="参数名称" ref="javabean的ID">
<bean>
如果不配置ID,默认全限定名#{number}eg:role#0。用ref引用另一个javabean
<!-- 构造器注入 -->
<bean id="role1" class="com.ssm.chapter10.pojo.Role"
c:_0="1" c:_1="role_name_1" c:_2="role_note_1" />
<!-- setter注入,参数值为roleName -->
1.2 Setter注入:
<bean id="" class="包名.类名">
<property name="参数名称" value="参数值">