韩顺平Spring笔记

合集下载

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)二、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)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是一个开源的用于简化采用Java语言开发企业级程序的一个分层的框架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相关知识点 (1)1.Spring框架的作用 (1)*2.Spring容器对象实例化 (1)3.Spring容器对Bean组件的管理 (2)2)Bean对象的创建时机 (2)4)Bean指定初始化和销毁方法 (2)*4.DI和IoC概念及应用 (2)5.DI注入的基本使用 (3)1.AOP概念 (4)1)什么是AOP (4)2.通知类型 (5)3.切入点表达式 (5)*a.方法限定表达式 (5)*b.类型限定表达式 (6)c.Bean的id值限定表达式 (6)d.参数限定表达式 (6)1.Spring的注解配置 (6)1)组件的自动扫描 (6)JdbcTemplate基本使用: (8)2)Spring如何整合Hibernate技术 (8)1. SSH框架工作流程 (9)整合SSH两种方案： (10)方案一： (10)方案二： (11)Spring开发异常处理： (12)ssh中哪些用到了动态代理？ (13)Spring相关知识点1.Spring框架的作用利用Spring框架整合Struts2,Hibernate等技术,可以管理应用程序中的DAO,Service等组件.利用Spring的IoC和AoP机制实现组件对象之间的低耦合调用.改善程序结构,便于扩展和维护.*2.Spring容器对象实例化BeanFactory---->ClassPathResource(加载src下xml配置)---->FileSystemResource(加载其他目录下的xml配置) ApplicationContext(推荐)-->ClassPathXmlApplicationContext-->FileSystemXmlApplicationContext容器实例化后,通过getBean("id属性")方法获取容器中的Bean对象.3.Spring容器对Bean组件的管理*1)Bean对象创建方式默认支持singleton和prototype模式.默认为singleton,可以在<bean>定义时用scope=""指定singleton:容器中只存在一个Bean对象,每次getBean取出的Bean对象相同.prototype:每次getBean取出一个新的Bean对象.以后如果在Web环境中,可以通过追加配置,将scope扩展成request,session等值.2)Bean对象的创建时机scope="singleton"时:Bean对象是随着容器创建而创建.通过lazy-init="true"属性可以将对象创建时机推迟到调用getBean方法时.其他创建方式:Bean对象是在getBean方法调用时创建.3)Bean对象的销毁时机singleton单例Bean对象,在Spring容器销毁时才销毁.非单例交给垃圾回收期,和程序中对象变量销毁时机一样.4)Bean指定初始化和销毁方法<bean init-method="方法名">可以指定对象创建时执行的初始化方法.该方法在构造方法后调用.<bean destroy-method="方法名">可以指定对象销毁前执行的销毁方法.该方法在对象销毁之前调用.(该属性适用于singleton)*4.DI和IoC概念及应用1)DI概念Dependency Injection : 依赖注入技术.在Spring容器中,两个组件之间存在调用关系,可以通过DI技术建立.在Spring容器中,主要采用以下注入方式:a. setter方式注入(推荐)依靠属性的set方法注入.使用方法如下:UserSerivce--调用-->UserDAO--在UserSerivce实现类中,添加一个UserDAO属性变量和setter方法--在Spring配置文件中,为UserSerivce添加setter注入配置<bean id="userService" class=""><property name="属性名" ref="要注入的DAO对象的id值"></property></bean>b.构造方式注入依靠构造方法注入.使用方法:--在UserService实现类中,添加一个UserDAO属性变量--在UserService实现类中,添加一个带参数的构造方法,参数类型为UserDAO类型.--在Spring配置中,定义构造注入<bean id="" class=""><constructor-arg index="构造参数索引"ref="要注入的bean对象id"></constructor-arg></bean>2)IoC概念Inverse of Controller 称为反向控制或控制反转.确切理解可以称为控制转移.意思是将对象创建,初始化销毁和调用关系指定这些控制逻辑提取交给第三方Spring容器负责.在Spring框架中通过DI技术实现了IoC控制思想.------------------------------------------------------------------------------------------------------------ 示例:UserService调用UserDAO体现出了IoC控制思想.由Spring容器负责Service和DAO对象创建和销毁,并且由Spring容器负责控制这两个组件对象的使用关系.其中Spring容器在指定使用关系时,采用了DI技术建立关系.5.DI注入的基本使用在使用Spring的DI时,可以注入多种数据类型.例如注入Bean对象,注入基本类型数据,注入一些集合数据.*1)注入Bean对象用ref指定Bean对象的id值.2)注入基本类型数据用value指定字符串或数值数据.3)注入集合类型数据a. List集合b.Set集合c.Map集合d.Properties集合-----------------练习----------------------案例1:采用Spring IoC方式实现UserService和UserDAO调用案例2:练习MessageService,注入各种类型数据.理论重点:DI和IoC概念,Spring对Bean组件的管理1.AOP概念1)什么是AOPAspect Oriented Programming (面向方面编程)OOP是面向对象编程,AOP是在OOP基础之上一种更高级的设计思想.OOP和AOP之间也存在一些区别,OOP侧重于对象的提取和封装.AOP侧重于方面组件,方面组件可以理解成封装了通用功能的组件,方面组件可以通过配置方式灵活的切入到某一批目标对象方法上.2)相关概念*a.方面组件(Aspect)封装了共同处理逻辑,将来可以切入到其他目标对象方法上的.例如事务控制,日志记录,权限控制等都可以采用方面组件封装*b.切入点(Pointcut)用于指定目标对象或方法的一个表达式.符合该表达式的方法将来启用方面组件更能处理.c.连接点(JoinPoint)连接点是切入点集合的一个元素.包含了方面组件与某一个目标方法衔接的所有信息.*d.通知(Advice)用于指定方面组件在目标方法上执行的时机.例如在目标方法之前调用,在目标方法之后调用等.e.目标对象(Target)通过切入点指定的对象.或者说成要启用方面组件功能的对象f.动态代理(AutoProxy)Spring的AOP机制采用了动态代理技术实现.当某个目标组件采用AOP切入之后,通过Spring容器getBean方法返回的对象,是一个动态生成的代理类型.后续使用代理对象执行业务方法时,代理对象会在内部调用目标方法和方面组件方法.3)AOP应用示例------------AOP编程步骤----------------a.先根据需求提取方面组件功能,并编写实现.b.根据需求提取目标对象,编写切入点表达式.c.根据需求选择方面功能和目标对象的切入时机,即选择合适的通知类型e.在spring容器配置中添加以下配置--将方面组件和目标组件都添加<bean>定义--添加aop配置元素.指定方面组件,切入点,通知元素.2.通知类型通知决定了方面组件功能在目标对象方法上执行的时机.Spring框架提供了以下5中类型通知.a.前置通知<aop:before>方面功能在目标方法之前调用.b.后置通知<aop:afterReturning>方面功能在目标方法之后调用.(如果目标方法抛出异常则不会执行方面功能)c.最终通知<aop:after>方面功能在目标方法之后调用.(目标方法有无异常都会执行方面功能)d.环绕通知<aop:around>方面功能在目标方法之前和之后调用.e.异常通知<aop:afterThrowing>方面功能在目标方法抛出异常之后调用.-----------------------------------try{//前置通知//环绕通知--前置部分执行目标方法//环绕通知--后置部分//后置通知}catch(){//异常通知}finally{//最终通知}3.切入点表达式用于指定目标对象及其方法.*a.方法限定表达式execution(修饰符? 返回类型方法名(参数列表) 抛出异常?)示例1:匹配所有对象中以set开始的方法.execution(* set*(..))示例2:匹配UserService类中的所有方法execution(* erService.*(..))示例3:匹配tarena.service包下所有类的所有方法execution(* tarena.service.*.*(..))示例4:匹配tarena.service包下及其子包中所有类的所有方法execution(* tarena.service..*.*(..))*b.类型限定表达式within(包名.类名)示例1:匹配UserService类中所有方法within(erService)示例2:匹配tarena.service包下所有类的方法within(tarena.service.*)示例3:匹配tarena.service包及其子包中所有类型的方法within(tarena.service..*)c.Bean的id值限定表达式bean(Bean组件定义的Id或Name值)<bean id="标示符" name="标示符">name和id作用相同,区别是name允许使用/特殊字符,而id不允许.示例1:匹配Bean定义时id=userService的对象的方法bean(userService)示例2:匹配Bean定义时id值以Service结尾的对象的方法bean(*Service)d.参数限定表达式args(参数类型)示例1:匹配只有一个参数,而且类型符合List的方法args(java.util.List)提示:以上表达式可以组合应用,利用&&,||进行连接.1.Spring的注解配置从Spring2.5版本开始,支持两套配置方法,即Schema XML方式和注解方式.从JDK5.0开始支持注解技术,spring2.5基于jdk5.0技术.注解方式特点:简单,方便,快捷.1)组件的自动扫描可按指定包路径,扫描该包下所有类,遇到指定注解标记,会将该Bean组件纳入到Spring 容器.(等价与<bean>)-------------使用方法如下-------------a.首先在Spring XML配置文件开启组件扫描,指定扫描路径<context:component-scan base-package="扫描包路径"/>b.在类定义前面使用下列标记@Component : 通用(各种组件都可以)@Controller : 控制组件使用(Action)@Service : 业务组件使用(Service)@Repository : 数据访问组件使用(DAO)注意:扫描bean组件,默认用类名首字母小写当id属性值.如果需要自定义,可以用@Repository("id值")c.如果需要对Bean对象创建进行控制,可以使用以下注解@Scope : 等价于原scope属性@PostConstruct : 等价于原init-method属性@PreDestroy : 等价于原destory-method属性d.如果需要将一个Bean对象给另一个Bean注入定义一个Bean对象变量,然后在变量定以前或setter方法定义前使用下面两种DI注入的注解配置.@Resource : 可以按类型匹配@Resource(name="id值") : 按指定id值名称匹配@Autowired : 可以按类型匹配@Autowired @Qulifier("id值") : 按指定id值名称匹配2)AOP注解配置---------------------------------使用方法如下------------------------------------------a.在Spring XML配置中开启AOP注解配置<aop:aspectj-autoproxy />b.定义方面组件,在方面组件中使用下面注解标记@Component //将方面组件扫描到容器(类定义前使用的标记)@Aspect //将当前组件指定为方面组件(类定义前使用的标记)@Pointcut("表达式") //指定切入点表达式(方法定义前使用的标记)@AfterThrowing()//异常通知(处理方法前使用)@AfterReturning()//后置通知(处理方法前使用)@After()//最终通知(处理方法前使用)@Before()//前置通知(处理方法前使用)@Around()//环绕通知(处理方法前使用)2.Spring整合数据访问技术Spring框架提供了整合JDBC和Hibernate等技术的支持.Spring框架对数据访问基础主要提供了以下支持.---Spring提供了一致的异常处理,Spring提供了一套异常类型,封装了不同数据访问技术的特有异常类型.例如DataAccessException---Spring提供了一套DAO支持类.DaoSupport,Template系列组件.例如JdbcDaoSupport,HibernateDaoSupportJdbcTemplate,HibernateTemplate---Spring提供了统一的事务处理(采用AOP方式管理).======================================1)Spring如何整合JDBC技术a.首先引入JDBC相关的开发包驱动开发包(mysqldriver.jar),连接池开发包(commons-dbcp.jar,commons-collection.jar,commons-pool.jar)b.根据数据表编写实体类c.编写DAO实现(基于JdbcDaoSupport,JdbcTemplate两个类)d.在Spring容器中配置DAO.需要注入dataSource对象.getBean("dao")<--UserDAO(使用template)<--注入--DataSource(Connection资源) JdbcTemplate基本使用:update() : 用于执行insert,update,delete操作的SQL语句queryForObject: 用于执行最多返回一行记录的select查询query:用于执行返回多行记录的select查询queryForInt:用于执行返回一行一列的select查询.2)Spring如何整合Hibernate技术a.引入以下开发包mysql驱动dbcp连接池hibernate开发包b.根据表添加实体类和hbm.xml映射文件c.编写DAO实现(基于HibernateDaoSupport,HibernateTemplate两个类)d.在Spring容器中配置DAO.需要注入sessionFactory对象.UserDAO(使用template)<--注入--SessionFactory<--注入--DataSource(Connection资源)HibernateTemplate的使用:save() : 保存对象update() : 更新对象delete() : 删除对象get()/load() : 按主键id查询find() : 执行hql语句===============练习========================1.采用Spring+JDBC方式实现对d_user的基本操作2.采用Spring+Hibernate方式实现对d_user的基本操作-----------------回顾Spring整合Hibernate步骤--------------------------------------1)按以下顺序引入开发包a.Spring的IoC和Aop开发包b.Hibernate开发包(含驱动)c.dbcp开发包2)添加实体类和hbm.xml映射文件3)编写DAO接口,然后编写实现类4)在Spring容器中配置DAO组件.5)完毕,测试DAOSpring整合Struts2步骤---------6)引入Struts2核心开发包(6个)7)添加Struts2 struts.xml配置文件和web.xml控制器配置8)根据请求编写Action组件,采用注入方式使用dao对象9)在Spring容器配置Action Bean.注入需要的DAO组件10)在struts.xml配置Action和请求的对应关系--添加一个整合插件包struts2-spring-plugin.jar.可以使struts访问spring容器.--<action>元素的class属性与spring容器中<bean>元素的id值一致11)在web.xml中添加ContextLoaderLisener配置,在启动时实例化Spring容器12)修改JSP,利用标签和表达式显示数据========================================================1.SSH框架工作流程1)启动Tomcat服务器.--加载web.xml,创建StrutsFilter控制器对象和ContextLoaderLisener对象--创建Struts控制器时,需要加载struts.xml,struts-plugin.xml,sstruts-default.xml,default.properties--创建ContextLoaderLisener对象时,需要加载spring的xml配置2)浏览器发送请求,请求进入StrutsFilter控制器对象--如果请求为list.action或/list格式,属于Action请求,会进入struts.xml中寻找匹配的<action>定义--如果请求为其他格式,例如/list.jsp,属于非Action请求会直接去调用jsp资源生成响应.3)在struts.xml配置中,根据<action>定义,由struts-spring-plugin.jar提供的ObjectFactory去Spring容器获取Action对象4)S pring容器创建Action对象,将DAO注入给Action对象,给Struts返回.5)Struts控制器调用Action对象进行请求的处理,处理完毕返回一个String类型的result 标识.6)Struts2控制器根据result标识调用Result组件对象生成响应信息.7)将响应信息输出给客户端.list.action-->web.xml-->struts.xml-->applicationContext.xml 整合SSH两种方案：方案一：方案分析：Action交给Spring容器管理。

韩顺平Linux视频教程—笔记（全）

韩顺平Linux视频教程—笔记（全）Linux操作系统学习linux的特点优点：1、免费的/开源的系统2、⽀持多线程/多⽤户的系统3、安全性好4、对内存和⽂件管理优越linux体积最少只需要内存4M，由于⼩所以可以做嵌⼊式开发缺点：操作相对困难Linus于1991年⾄1994年将unix的微型版minis加以开发出linux现在redhat红帽⼦、BSD、SUN等公司进⾏再发⾏在windows环境下可以使⽤(VM等)虚拟机来运⾏linux在linux运⾏startx命令可以进⼊图形操作界⾯root是linux下的系统管理员普通⽤户登陆后可以⽤su- 切换为系统管理员关机命令shutdown -h now ⽴刻进⾏关机shutdown -r now 现在重新启动计算机reboot 现在重新启动计算机logout 注销vi编辑器是linux下最有名的编辑器，也是学习linux必须掌握的⼯具，在unix下也可使⽤vi进⾏程序的开发linux可以做java/c开发在linux的vi编辑器内写⼀下简单的java程序“hello,world”1、Vi Hello.java2、输⼊i[进⼊到插⼊模式]public class hello{public static void main(String []args){System.out.println("hello,world");}}3、输⼊esc键[进⼊命令模式]4、输⼊wq保存退出/q!退出但不保存6、编译javac hello.javajavac Hello.java7、运⾏ java Hello [java运⾏的是class⽂件]ls命令显⽰当前⽂件ls -l命令显⽰详细⽂件列表如何在linux下开发c程序或是c++(cpp)程序建⽴vi hello.cpp#include <stdio.h>int main(){printf("hello!");return 0;}gcc hello.cpp ⽤gcc编译器编译出来未命名会是a.out⽂件gcc -o [⽂件名] [源⽂件名] ⽤gcc编译器编译⽂件命名/a.out 在linux下运⾏c程序只要输⼊/就可以运⾏------------------------------------------------------------linux下的⽂件⽬录linux的⽂件系统是采⽤级层式的树状⽬录结构，在此结构中的最上层是根⽬录“/”，然后在此⽬录下再创建其他的⽬录深刻理解linux⽂件⽬录是⾮常重要的。

韩顺平循序渐进学java从入门到精通(全知识点笔记整理)

Java韩顺平笔记第1讲内容介绍.项目演示.原理剖析1. 课程包括：java面向对象编程，java图形界面，java数据库编程，java文件i/o流，java网络编程，java的多线程2. Java历史：1990 sun 启动绿色计划 1992 创建 oak语言—> java1994 gosling 参加硅谷大会演示java功能震惊世界 1995 sun 正式发布java第一个版本，目前最新的是jdk7.03. java开发工具：记事本，jcreator，jbuilder，netbean，eclipse4. jdk包括：jre（java运行环境）java的工具：编译器javac.exe解释执行器java.exe java的类库：3600多个，常用的150多个5. 第一个程序：//功能：显示―HelloWorld‖//public:表示类是公共的，一个文件中只有一个public类 //class:表示这个是一个类//HelloWorld:类名（公共类的类名，必须和文件名一样）public class HelloWorld {//一个主函数，程序的入口 public static void main (String args[]) {//执行语句System.out.println("helloWorld!"); } }6. Java源程序（.java文件）——>java字节码文件（.class文件）——>由解释执行器（java.exe）将字节码文件加载到java虚拟机（jvm）——>字节码文件（.class）就会在java虚拟机中执行l,average); } }第2讲变量.数据类型1. 在java里面int占4个字节，long占8个字节2. Java基本数据类型：整数：(byte一个字节：-128---127 int四个字节：-2147483648---+2147483647short两个字节：-32768---+32767 long八个字节：)小数（浮点）：float double布尔：boolean字符：char（两个字节，可以存放汉字, char test1 ='中';）引申到字符串（类）3.在java中对char进行运算的时候，直接是当做ASCII码对应的整数4.数据不能从高精度到低精度的转换Byte<short<int<long<float<doublefloat a=3.4；是过不去的，在java中小数默认是double（双精度）的应该写成是float a=3.4f；不过可以强制转换：int a=(int)1.2; intb=(int)1.95. int a=1;int b=a+1.2; a先是往高精度转换，然后赋给b，就报错改成int a=1;double b=a+1.2; 或者int a=1;float b=a+1.2f; 就解决了第4讲流程控制1. switch case语句中，switch条件表达式的数据类型应该和后面case的类型一致2. switch case语句中，可用的数据类型主要是：byte short int char enum第5讲类与对象1. 面向对象编程-类与对象类名首字母大写类里面的元素叫类的成员变量/属性2. 类的定义package 包名；class 类名extends 父类implements接口名{成员变量；构造方法；成员方法；}3. 如何创建对象：先声明再创建Cat cat1；cat1=new Cat();一步到位Cat cat1 =new Cat();4. 引用传递类似于指针一样第8讲this 类变量1. this属于类的对象的而不是属于类的2. 5this不能在类的外部使用，只能在类定义时候使用！3. 可以用类名直接访问静态变量第9讲类方法封装1.类变量是该类的所有对象共享的对象,一改全改了2.定义语法：访问修饰符static 数据类型变量名3. public class Demo9{static int i=1;static{System.out.println("zhixingyicile");i++;}//会自动执行一次，也只有一次public Demo9(){System.out.println("ffffffff");i++;}public static void main(String args[]){Demo9 t1=new Demo9();System.out.println(Demo9.i);Demo9 t2=new Demo9();System.out.println(i);}}4.类方法（静态方法、静态函数）：属于所有对象实例的5.Java中:类变量（static）原则上用类方法（static）去访问；类方法中不能访问非静态变量，就是非类变量，但是普通的成员方法可以访问静态变量（类变量）使用：类名.类方法名对象名.类方法名6.非类变量就是实例变量，属于每个对象自己的7.Java面向对象编程的三（四）大特征：封装、继承、多态（、抽象）8.抽象：把一类事物的共有的属性和行为提取出来，形成一个物理模板，此研究问题的方法就是抽象9.封装：把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作。

韩顺平循序渐进学java从入门到精通课件笔记29讲到31讲

韩顺平循序渐进学java从入门到精通课件笔记29讲到31讲项目经理：1、懂技术2、懂行业图形界面（gui）1、sun已经提供了一个跨平台gui开发工具包awt提供了好多类与接口。

但有缺点《致命的一个本地化lcd》2、sun又创建了一个swing框架，解决了lcd问题。

swing是awt的升级版本。

就是继承的关系。

3、IBM认为swing消耗内存，创建了一个新的gui库，就是swt。

4、IBM为了方便开发swt程序，在swt基础上又创建出一个更易用，功能强大的图形包JFace。

我们重点学习swing。

了解awt。

做图形界面在MyEclipse下开发。

Eclipse最早是IBM附属公司oti开发的。

是开源的，可扩展的开发环境，是最流行的java 开发工具，但是不能开发java ee项目，否则需要安装MyEclipse，现在一般都安装MyEclipse，不单独安装Eclipse。

IDE 集成开发环境。

（vs2005 jcreater MyEclipse等等）开发java的IDE：NetBeans jbuilder jcreater MyEclipseswing组件一览表JFrame是Frame的子类，JButton也属于容器类的布局管理器：通过布局管理器来管理控件的大小与位置。

共五种，常用3种，流式布局管理器，边界布局管理器，网格布局管理器，卡片布局管理器，网格包布局管理器第三十讲：边界布局管理器：将容器化为东南西北中五个区域，中间区域最大。

JFrame JDialog对话框自建默认的是边界布局。

注意事项：1、不是五个部件都必须添加2、中部组件会自动的调节大小3、JFrame JDialog默认布局管理器就是BorderLayout。

/***BorderLayout布局*1继承JFrame*定义需要的组件*创建组件(构造函数)*添加组件*对窗体设置*/package com.test1;import java.awt.*;import javax.swing.*;public class Demo8_2 extends JFrame {JButton jb1,jb2,jb3,jb4,jb5;public static void main(String[] args) {Demo8_2 dd =new Demo8_2();}public Demo8_2(){//创建组件jb1=new JButton("中部");jb2=new JButton("北部");jb3=new JButton("东部");jb4=new JButton("南部");jb5=new JButton("西部");//添加各个组件this.add(jb1,BorderLayout.CENTER);this.add(jb2, BorderLayout.NORTH);this.add(jb3, BorderLayout.EAST);this.add(jb4,BorderLayout.SOUTH);this.add(jb5, BorderLayout.WEST);//设置窗体属性this.setTitle("这是一个演示窗体");this.setSize(200,200);this.setLocation(500, 500);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setVisible(true);}}流式布局flowLayout，从左到右跟网页差不多注意事项：1、流式布局不限制所管理组件的大小，允许他们有最佳大小2、当容器被缩放时，组建的位置可能发生变化，但是组建的大小不发生变化（做编程时，通常不许窗口大小变化）3、默认组件是居中对齐的package com.test1;import java.awt.*;import javax.swing.*;;public class demo8_3 extends JFrame{//定义需要组建.JButton jb1,jb2,jb3,jb4,jb5,jb6;public static void main(String[] args) {demo8_3 demo=new demo8_3();}//构造函数public demo8_3(){//创建组件jb1=new JButton("关羽");jb1.setSize(100, 200);jb2=new JButton("张飞");jb3=new JButton("刘备");jb4=new JButton("诸葛亮");jb5=new JButton("曹操");jb6=new JButton("魏延");//添加组件this.add(jb1 );this.add(jb2 );this.add(jb3 );this.add(jb4 );this.add(jb5 );this.add(jb6 );//设置布局管理器,流式布局默认的是居中对齐this.setLayout(new FlowLayout(FlowLayout.RIGHT));//设置窗体属性this.setTitle("这是一个演示窗体");this.setSize(200,280);this.setLocation(500, 500);//禁止用户修改控件大小.this.setResizable(false);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setVisible(true);}}网格布局：网格布局容器分割为多行多列，将组件放在格中。

韩顺平java从入门到精通视频教程(全94讲)学习笔记整理(齐全)

java平台1、J2SE java开发平台标准版2、J2EE java开发平台企业版java程序需要在虚拟机上才可以运行，换言之只要有虚拟机的系统都可以运行java程序。

不同系统上要安装对应的虚拟机才可以运行java程序开发步骤1、编写源文件 (.java)2、编译源文件为类文件(.class)可用J2SE或J2EE编译3、在虚拟机上运行注释//单行注释/* */多行注释java内容介绍java编程可以分成三个方向：1、java se (j2se)桌面开发 java中的基础中的基础2、java ee (j2ee)web开发3、java me (j2me)手机开发java se课程介绍java面向对象编程(基础)java图开界面开发java数据库编程java文件io流编程java网络编程java多线程编程java ee基础1java面向对象编程--数据库编程-->java sejava 基础2html--css--javascript-->div+cssjava ee中级部分Servlet--Jsp-->mvc模式java ee高级部分Struts--Ejb--Hibernate--Spring--Ajax(ext,dw2)-->ssh框架java之父gosling1990 sun启动绿色计划1 | 4451992 创建oak语言-->java1994 gosling参加硅谷大会演示java功能，震惊世界1995 sun正式发布java第一个版本，目前最新是jdk7.0java开发工具记事本、(jcreator、jbuilder退出舞台了)、netbean、eclipse如何选择开发工具先选择记事本，对java有一定了解后再使用eclipse高级开发工具为什么呢？1、更深刻的理解java技术，培养代码感2、有利于公司面试java语言的特点1、java语言是简单的2、java语言是面向对象的3、java语言是跨平台(操作系统)的[即一次编译，到处运行]4、java是高性能的java第一个程序hello.java运行java程序要安装和配置jdkjdk是什么？1、jdk全称java dvevlopment kit中文java开发工具包2、jdk是sun公司开发的3、jdk包括jre(java runtime envirnment)java运行环境、一堆java工具和java基础的类库(类共3600左右，常用类在150个左右)4、可以在下载**开发安装jdk,用户执行需要安装jre配置JDK添加环境变量即可windows下配置jdk在计算机属性--高级设置--环境变量--添加PATH将JDK所在路径指定即可。

Spring课堂笔记讲解

第一篇：Spring概述1、Spring框架内核IoC（Inverse Of Control）：反转控制。

AOP（Aspect Oriented Programming）：面向切面编程。

2、Spring的体系结构3、Spring开发所需的资源第二篇：Spring核心之IoC（控制反转）1、拷贝核心jar包：2、IoC的概念：3、资源交给Spring管理3.1建立spring的配置文件：a、schema约束文档资料位置b、schema引入后xml没有提示的解决方案c、把DAO实现交给Spring容器（Map结构）管理a、把核心jar包加入到classpath中b、启动Spring容器4、依赖注入：DI(Dependency Injection)5、Spring核心类或接口核心接口：ApplicationContextClassPathXmlApplicationContext：加载位于classpath中的spring配置文件。

FileSystemXmlApplicationContext：加载位于本地磁盘上的spring配置文件。

了解：BeanFactory和ApplicationContext获取Bean的区别6、Bean的初始化●方式一：使用默认的构造方法。

（推荐，重点）注意：Bean要有默认的构造方法●方式二：静态工厂方法初始化（遗留老系统）●方式三：实例工厂方法初始化（遗留老系统）7、bean的存活范围<bean的scope属性>:取值：singlton(默认值)：单例的。

在spring容器中实例只有一个。

prototype:非单例的。

用的时候都会创建新的对象。

request：请求范围。

（只能用在web环境下）session：会话范围。

（只能用在web环境下）8、bean的生命周期有关配置注意：9、依赖注入：重点9.1通过构造方法注入9.2setter属性注入：重点9.3p名称空间：9.4SpEL：Spring Expression Language9.5注入数组或集合10、团队开发按模块编写spring配置文件。

spring课堂笔记

Spring day012008-12-24 田天一、Spring FrameWork概述1、企业级应用开发应注意的内容（1）分层：一般意义上分三层·表示层：1）接收客户端请求2）展示结果·业务层1）封装数据访问的逻辑2）事务、安全、调用数据访问接口·持久层1）封装数据访问的逻辑2）给业务层提供透明的数据访问的方式注：透明：提供完整的API（2）基础代码（中间件服务）基础代码：即基础设施，事务、安全、日志、集成、邮件、消息、任务调度…·通用，与具体业务无关·变化少，实现复杂（3）测试（4）如何解决企业级应用：·完全实现所有的代码（包括基础代码）·J2EE（标准的）：用来简化企业级应用的包括JSP、Servlet、EJB、JPA、JMS….·Spring（非标准的）2、Spring是一个开源的，用来简化企业级开发复杂性的分层框架。

3、Spring特点：（1）封装了大量企业级服务（简化了调用企业级应用的代码）（2）提供了一个容器（这个容器可以使得容器中的业务主键可以组装在一起，减少模块之间的耦合性，利于测试、维护并且支持AOP编程，为业务组件提供灵活的中间件服务）（3）Spring框架对应用中的每一层均提供了相应的支持或实现，既可以使用Spring全部功能也可以使用其部分功能，或者集成其他子框架（比如struts。

）（4）Spring是个非侵入式的轻量级框架。

·非侵入式：指应用尽量的少的依赖框架的API4、为什么使用Spring？（1）它可以简化企业级应用的开发（2）它可以方便的集成其他的技术框架（3）使用Spring开发的代码易维护、易测试（4）可以不再使用EJB技术来实现企业级应用二、Spring框架的组成1、SpringCore ：核心容器（1）BeanFactory 接口实现（2）作用：提供组件的创建（实例化）、装配（依赖关系）、销毁等基本功能。

韩顺平linux教学视频学习笔记(四)

第四天主要任务：A、网络信息查询：B、远程登录服务器sshd（linux自带的服务）——多用户一、任务调度的使用crontab1、设置任务Crontab -e 即进入任务分配界面2、希望，每隔一定时间去执行date > /home/mydata1 【覆盖写时间】注：Date 【显示当前时间】3、希望，每天凌晨2:00去执行date >> /home/mydate2a.Crontab -eb.输入：0 2 * * date >> /home/mydate2分时月年4、希望，每隔一分钟去执行a.Crontab -eb.输入* * * * * date >> .home/mydate2c.查看调度情况注：查看文件内容使用的是cat ……5、怎样调度多个任务1)第一种：在crontab中直接写a.Crontab -eb.（第二个任务是把mydate2拷贝到root）c.查看调度情况2)第二种：可以把所有的任务，写入到可执行文件中（shell编程）a.编写一个文件Vi mytask.shb.输入：（注：此处并没有设置时间限制）c.退出后，查看发现mytask 文件不可执行d.修改执行权限Chmod 744 mytask.she.把mytask.sh交给crontab去执行●Crontab -e●删除原内容，输入：●退出后，查询root文件夹，发现出现了mydate3f.若要修改任务，进入root修改mytask.sh 里面的内容即可。

6、如何终止任务二、进程的介绍和管理1、概念进程：就是正在执行的程序。

线程：a，线程是轻量级的进程b，进程有独立的地址空间，线程没有c，线程不能独立存在，它是有由进程创建。

（linux里面用fork）d，相对讲，线程耗费的CPU和内存小于进程。

2、查看linux中的进程3、结束进程kill 进程号kill all 可以把此进程及其子进程统统杀掉4、查询动态进程Top按q 退出。

韩顺平循序渐进学java 从入门到精通课件笔记第七十讲到第七十三讲

由于对数据库操作后有很多重复代码.这样可以把操作封装成一个类,这个类可以完成对表的操作.第七十一讲: 初步理解模式的概念(mv):增加项目的可维护性,尤其在做一个大项目的时候,如果没有一个好的方案的话,那么就会很悲剧了.软件开发也是一个渐进的过程./*** 写成一个 ming版的学生管理系统* 1，查询任务* 2，添加学生*/package com.test1;import java.awt.*;import java.awt.event.*;import java.sql.*;import javax.swing.*;public class StudentManagement extends JFrame implements ActionListener {//定义一些控件JPanel jp1,jp2;JLabel jl;JButton jb1,jb2,jb3,jb4;JTable jt ;JTextField jtf;JScrollPane jsp =null;Connection ct=null;PreparedStatement ps=null;StuModel sm=null;public static void main(String[] args) { StudentManagement ta=new StudentManagement();}public StudentManagement(){jp1=new JPanel();jl=new JLabel("请输入名字:");jtf=new JTextField(20);jb1=new JButton("查询");//注册监听jb1.addActionListener(this);//把各个控件加入到jp1;jp1.add(jl);jp1.add(jtf);jp1.add(jb1);jp2=new JPanel();jb2=new JButton("添加");jb3 =new JButton("修改");jb4 =new JButton("删除");//注册监听jb2.addActionListener(this);jb3.addActionListener(this);jb4.addActionListener(this);jp2.add(jb2);jp2.add(jb3);jp2.add(jb4);//创建一个数据模型对象sm =new StuModel();//初始化JTablejt=new JTable(sm);//初始化jspjsp=new JScrollPane(jt);//吧jsp放进到JFramethis.add(jsp);this.add(jp1,BorderLayout.NORTH);this.add(jp2,BorderLayout.SOUTH);this.setSize(500,400);this.setLocation(200, 200);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setVisible(true);}@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stub//判断是那个按钮被点击//如果相应与监听在同一个类中也可以用下面方法.if(e.getSource()==jb1){//System.out.println("用户希望查询");测试用的//因为把表的数据封装到StuModel中,我们就可以比较简单地完成查询任务String name=this.jtf.getText().trim();//写一个sql语句String sql ="select * from student where stuName='"+name+"'";//构建新的数据模型类并更新sm =new StuModel(sql);jt.setModel(sm);}//当用户点击添加else if(e.getSource()==jb2){//合理应该为模式的状态,否则,还没有插完就会执行下面的语句,导致无法更新.StuAddDialog sad =new StuAddDialog(this,"添加学生",true);//重新再获得新的数据模型sm =new StuModel();jt.setModel(sm);}else if(e.getSource()==jb3){System.out.print("aaaa");int rownum =this.jt.getSelectedRow();if(rownum==-1){//提示JOptionPane.showMessageDialog(this, "请选择一行");return;//代表不要再往下面走了,谁调用就返回给谁}//显示修改对话框new StudentUpdateDialog(this,"修改对话框",true,sm,rownum);}//当前用户点击删除else if(e.getSource()==jb4){//得到该学生的id//getSelectedRo会返回用户点击的行//如果一行都没选,则会返回-1int rownum=this.jt.getSelectedRow();if(rownum==-1){//提示JOptionPane.showMessageDialog(this, "请选择一行");return;//代表不要再往下面走了,谁调用就返回给谁}//得到学生的编号String stuId=(String)sm.getValueAt(rownum, 0);//System.out.print(stuId);//测试用的//连接数据库,完成删除任务try{//加载驱动Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");//System.out.print("1");//测试用的//得到连接ct=DriverManager.getConnection("jdbc:sqlserver://127.0.0.1:1433;d atabaseName=spdb1","sa","h123");//System.out.print("2");//测试用的ps=ct.prepareStatement("delete from student wherestuid='"+stuId+"'");//System.out.print("3");//测试用的ps.executeUpdate();}catch(Exception ex){ex.printStackTrace();}finally{try {if(ps!=null) ps.close();if(ct!=null) ps.close();} catch (SQLException e1) {// TODO Auto-generated catch blocke1.printStackTrace();}}sm =new StuModel();jt.setModel(sm);}}}/*** 这是我的一个Student表的模型* 可以把对student表的各种操作封装到该模型中*/package com.test1;import java.sql.*;import java.util.V ector;import javax.swing.JTable;import javax.swing.table.AbstractTableModel; public class StuModel extends AbstractTableModel{V ector rowData, columnNames;JTable jt=null;//定义操作数据库需要的东西PreparedStatement ps=null;Connection ct=null;ResultSet rs =null;public void init(String sql){if(sql ==null){sql ="select * from student";}//中间处理jt =new JTable();columnNames=new V ector();//设置列名columnNames.add("学号");columnNames.add("名字");columnNames.add("性别");columnNames.add("年龄");columnNames.add("籍贯");columnNames.add("系别");//rowData可以存放多行rowData =new V ector();try{//加载驱动Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");//System.out.print("1");//测试用的//得到连接ct=DriverManager.getConnection("jdbc:sqlserver://127.0.0.1:1433;databaseName=spdb1","s a","h123");//System.out.print("2");//测试用的ps=ct.prepareStatement(sql);//System.out.print("3");//测试用的rs=ps.executeQuery();//System.out.print("4");//测试用的while(rs.next()){V ector hang =new V ector();hang.add(rs.getString(1));hang.add(rs.getString(2));hang.add(rs.getString(3));hang.add(rs.getInt(4));hang.add(rs.getString(5));hang.add(rs.getString(6));//加入到rowDatarowData.add(hang);}//System.out.print("5");//测试用的}catch(Exception e){e.printStackTrace();}finally{try {if(rs!=null) rs.close();if(ps!=null) ps.close();if(ct!=null) ct.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}//通过传递的sql语句来获得数据模型public StuModel(String sql){init(sql);}//构造函数,初始化我们的数据模型public StuModel(){this.init(null);}public void addStu(String sql){//根据用户输入的sql语句完成添加任务.}@Overridepublic String getColumnName(int column) {// TODO Auto-generated method stubreturn (String)this.columnNames.get(column);}@Override//得到共有多少列public int getColumnCount() {// TODO Auto-generated method stub//System.out.print("getColumnCount");//测试所用return this.columnNames.size();}@Override//得到共有多少行public int getRowCount() {// TODO Auto-generated method stubreturn this.rowData.size();}@Override//得到某行某列的数据public Object getV alueAt(int rowIndex, int columnIndex) {// TODO Auto-generated method stubreturn ((V ector)this.rowData.get(rowIndex)).get(columnIndex);}}package com.test1;import java.awt.*;import java.awt.event.*;import java.sql.*;import javax.swing.*;public class StuAddDialog extends JDialog implements ActionListener{//定义我需要的swing组件JLabel jl1, jl2,jl3, jl4, jl5 ,jl6;JButton jb1,jb2;JTextField jtf1,jtf2,jtf3,jtf4,jtf5,jtf6;JPanel jp1,jp2,jp3;//构造函数 Frame代表父窗口口,title代表窗口的名字,model指定是模式窗口,还是非模式的窗口public StuAddDialog(Frame owner,String title,boolean model){super(owner,title, model); //调用父类构造方法,达到模式对话框效果jl1=new JLabel("学号");jl2=new JLabel("姓名");jl3=new JLabel("性别");jl4=new JLabel("年龄");jl5=new JLabel("籍贯");jl6=new JLabel("系别");jtf1=new JTextField();jtf2=new JTextField();jtf3=new JTextField();jtf4=new JTextField();jtf5=new JTextField();jtf6=new JTextField();jb1=new JButton ("添加");jb2=new JButton ("取消");jp1=new JPanel();jp2=new JPanel();jp3=new JPanel();//设置布局jp1.setLayout(new GridLayout(6,1)); jp2.setLayout(new GridLayout(6,1));//添加组件jp1.add(jl1);jp1.add(jl2);jp1.add(jl3);jp1.add(jl4);jp1.add(jl5);jp1.add(jl6);jp2.add(jtf1);jp2.add(jtf2);jp2.add(jtf3);jp2.add(jtf4);jp2.add(jtf5);jp2.add(jtf6);jp3.add(jb1);jp3.add(jb2);this.add(jp1,BorderLayout.WEST); this.add(jp2,BorderLayout.CENTER);this.add(jp3,BorderLayout.SOUTH);//注册监听jb1.addActionListener(this);//展现this.setSize(300,200);this.setLocation(200, 300);this.setVisible(true);}@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubif(e.getSource()==jb1){//对用户点击添加按钮后的响应动作//连接数据库Connection ct =null;PreparedStatement ps =null;try {//加载驱动Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");//获取连接ct=DriverManager.getConnection("jdbc:sqlserver://127.0.0.1:1433;d atabaseName=spdb1","sa","h123");//预编译的都是通过添加参数的方式来赋值ps=ct.prepareStatement("insert into student values (?,?,?,?,?,?)");ps.setString(1, this.jtf1.getText());ps.setString(2, this.jtf2.getText());ps.setString(3, this.jtf3.getText());ps.setInt(4, Integer.parseInt(this.jtf4.getText()));ps.setString(5, this.jtf5.getText());ps.setString(6, this.jtf6.getText());int i=ps.executeUpdate();if(i==1){System.out.print("添加成功ok");}else{System.out.print("添加失败");}} catch (Exception e1) {// TODO Auto-generated catch blocke1.printStackTrace();}finally{try {ps.close();ct.close();} catch (SQLException e1) {// TODO Auto-generated catch blocke1.printStackTrace();}}}}}/*** 修改学生界面*/package com.test1;import java.awt.*;import java.awt.event.*;import java.sql.*;import javax.swing.*;public class StudentUpdateDialog extends JDialog implements ActionListener{//定义我需要的swing组件JLabel jl1, jl2,jl3, jl4, jl5 ,jl6;JButton jb1,jb2;JTextField jtf1,jtf2,jtf3,jtf4,jtf5,jtf6;JPanel jp1,jp2,jp3;//构造函数 Frame代表父窗口口,title代表窗口的名字,model指定是模式窗口,还是非模式的窗口public StudentUpdateDialog(Frame owner,String title,boolean model,StuModel sm,int rownum){super(owner,title, model); //调用父类构造方法,达到模式对话框效果jl1=new JLabel("学号");jl2=new JLabel("姓名");jl3=new JLabel("性别");jl4=new JLabel("年龄");jl5=new JLabel("籍贯");jl6=new JLabel("系别");jtf1=new JTextField();jtf2=new JTextField();jtf3=new JTextField();jtf4=new JTextField();jtf5=new JTextField();jtf6=new JTextField();//初始化数据jtf1.setText((String)sm.getValueAt(rownum, 0));jtf1.setEditable(false);jtf2.setText((String)sm.getValueAt(rownum, 1));jtf3.setText((String)sm.getValueAt(rownum, 2));jtf4.setText(sm.getValueAt(rownum, 3)+"");jtf5.setText((String)sm.getValueAt(rownum, 4));jtf6.setText((String)sm.getValueAt(rownum, 5));jb1=new JButton ("修改");jb2=new JButton ("取消");jp1=new JPanel();jp2=new JPanel();jp3=new JPanel();//设置布局jp1.setLayout(new GridLayout(6,1));jp2.setLayout(new GridLayout(6,1));//添加组件jp1.add(jl1);jp1.add(jl2);jp1.add(jl3);jp1.add(jl4);jp1.add(jl5);jp1.add(jl6);jp2.add(jtf1);jp2.add(jtf2);jp2.add(jtf3);jp2.add(jtf4);jp2.add(jtf5);jp2.add(jtf6);jp3.add(jb1);jp3.add(jb2);this.add(jp1,BorderLayout.WEST);this.add(jp2,BorderLayout.CENTER);this.add(jp3,BorderLayout.SOUTH);//注册监听jb1.addActionListener(this);//展现this.setSize(300,200);this.setLocation(200, 300);this.setVisible(true);}@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubif(e.getSource()==jb1){//对用户点击添加按钮后的响应动作//连接数据库Connection ct =null;PreparedStatement ps =null;try {//加载驱动Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");//获取连接ct=DriverManager.getConnection("jdbc:sqlserver://127.0.0.1:1433;d atabaseName=spdb1","sa","h123");//预编译的都是通过添加参数的方式来赋值ps=ct.prepareStatement("update student setstuName=?,stuSex=?,stuAge=?,stuJg=?,stuDept=? where stuId=?");ps.setString(1, this.jtf2.getText());ps.setString(2, this.jtf3.getText());ps.setInt(3, Integer.parseInt(this.jtf4.getText()));ps.setString(4, this.jtf5.getText());ps.setString(5, this.jtf6.getText());ps.setString(6, this.jtf1.getText());int i=ps.executeUpdate();if(i==1){System.out.print("修改成功ok");}else{System.out.print("修改失败");}} catch (Exception e1) {// TODO Auto-generated catch blocke1.printStackTrace();}finally{try {ps.close();ct.close();} catch (SQLException e1) {// TODO Auto-generated catch blocke1.printStackTrace();}}}}}第七十二讲:下面将前面的model1模式改成model2模式Model2模式的最大特点是: 界面和后台操作是分离的,代码复用性高,可读性好,可维护性高;缺点是:复杂性高.现在大部分公司采用的是model2模式./*** Model2 模式* 写成一个ming版的学生管理系统* 1，查询任务* 2，添加学生*/package com.test2;import java.awt.*;import java.awt.event.*;import java.sql.*;import javax.swing.*;public class StudentManagement extends JFrame implements ActionListener {//定义一些控件JPanel jp1,jp2;JLabel jl;JButton jb1,jb2,jb3,jb4;JTable jt ;JTextField jtf;JScrollPane jsp =null;StuModel sm=null;public static void main(String[] args) {StudentManagement ta=new StudentManagement();}public StudentManagement(){jp1=new JPanel();jl=new JLabel("请输入名字:");jtf=new JTextField(20);jb1=new JButton("查询");//注册监听jb1.addActionListener(this);//把各个控件加入到jp1;jp1.add(jl);jp1.add(jtf);jp1.add(jb1);jp2=new JPanel();jb2=new JButton("添加");jb3 =new JButton("修改");jb4 =new JButton("删除");//注册监听jb2.addActionListener(this);jb3.addActionListener(this);jb4.addActionListener(this);jp2.add(jb2);jp2.add(jb3);jp2.add(jb4);//创建一个数据模型对象sm =new StuModel();//初始化JTablejt=new JTable(sm);//初始化jspjsp=new JScrollPane(jt);//吧jsp放进到JFramethis.add(jsp);this.add(jp1,BorderLayout.NORTH);this.add(jp2,BorderLayout.SOUTH);this.setSize(500,400);this.setLocation(200, 200);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setV isible(true);}@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stub//判断是那个按钮被点击//如果相应与监听在同一个类中也可以用下面方法.if(e.getSource()==jb1){//因为把表的数据封装到StuModel中,我们就可以比较简单地完成查询任务String name=this.jtf.getText().trim();//写一个sql语句String sql ="select * from student where stuName='"+name+"'";//构建新的数据模型类并更新sm =new StuModel(sql);jt.setModel(sm);}//当用户点击添加else if(e.getSource()==jb2){//合理应该为模式的状态,否则,还没有插完就会执行下面的语句,导致无法更新.StuAddDialog sad =new StuAddDialog(this,"添加学生",true);//重新再获得新的数据模型sm =new StuModel();jt.setModel(sm);}else if(e.getSource()==jb3){System.out.print("aaaa");int rownum =this.jt.getSelectedRow();if(rownum==-1){//提示JOptionPane.showMessageDialog(this, "请选择一行");return;//代表不要再往下面走了,谁调用就返回给谁}//显示修改对话框new StudentUpdateDialog(this,"修改对话框",true,sm,rownum);}//当前用户点击删除else if(e.getSource()==jb4){//得到该学生的id//getSelectedRo会返回用户点击的行//如果一行都没选,则会返回-1int rownum=this.jt.getSelectedRow();if(rownum==-1){//提示JOptionPane.showMessageDialog(this, "请选择一行");return;//代表不要再往下面走了,谁调用就返回给谁}//得到学生的编号String stuId=(String)sm.getV alueAt(rownum, 0);//System.out.print(stuId);//测试用的StuModel temp=new StuModel();//创建一个sql 语句String sql ="delete from student where stuId=?";String[] paras ={stuId};if(!temp.updateStudent(sql, paras)){//提示JOptionPane.showMessageDialog(this, "删除失败");}sm =new StuModel();//解决一次无用的查询jt.setModel(sm);}}}/*** 这是我的一个Student表的模型* 可以把对student表的各种操作封装到该模型中*/package com.test2;import java.sql.*;import java.util.Vector;import javax.swing.JTable;import javax.swing.table.*;public class StuModel extends AbstractTableModel{Vector rowData, columnNames;JTable jt=null;//定义操作数据库需要的东西PreparedStatement ps=null;Connection ct=null;ResultSet rs =null;String driver="com.microsoft.sqlserver.jdbc.SQLServerDriver"; String url="jdbc:sqlserver://127.0.0.1:1433;databaseName=spdb1"; String user="sa";String password ="h123";//添加,删除,修改学生由于添加的参数不确定,因此用数组来传递参数public Boolean updateStudent( String sql,String [] paras ){boolean b=true;try{//1加载驱动Class.forName(driver);//2得到连接ct=DriverManager.getConnection(url,user,password);//3创建ps对象ps=ct.prepareStatement(sql);//给ps的?赋值for(int i=0;i<paras.length;i++){//sql 中给int 传入String类型,dbms会自动转的.ps.setString(i+1, paras[i]);}//4执行操作if( ps.executeUpdate()!=1){b=false;}}catch (Exception e){b=false;e.printStackTrace();}finally{try {if(ps!=null) ps.close();if(ct!=null) ct.close();} catch (SQLException e) {e.printStackTrace();}}return b;}public void init(String sql){if(sql ==null){sql ="select * from student";}//中间处理jt =new JTable();columnNames=new Vector();//设置列名columnNames.add("学号");columnNames.add("名字");columnNames.add("性别");columnNames.add("年龄");columnNames.add("籍贯");columnNames.add("系别");//rowData可以存放多行rowData =new Vector();try{//加载驱动Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");//System.out.print("1");//测试用的//得到连接ct=DriverManager.getConnection("jdbc:sqlserver://127.0.0.1:1433;d atabaseName=spdb1","sa","h123");//System.out.print("2");//测试用的ps=ct.prepareStatement(sql);//System.out.print("3");//测试用的rs=ps.executeQuery();//System.out.print("4");//测试用的while(rs.next()){Vector hang =new Vector();hang.add(rs.getString(1));hang.add(rs.getString(2));hang.add(rs.getString(3));hang.add(rs.getInt(4));hang.add(rs.getString(5));hang.add(rs.getString(6));//加入到rowDatarowData.add(hang);}//System.out.print("5");//测试用的}catch(Exception e){e.printStackTrace();}finally{try {if(rs!=null) rs.close();if(ps!=null) ps.close();if(ct!=null) ct.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}//通过传递的sql语句来获得数据模型public StuModel(String sql){init(sql);}//构造函数,初始化我们的数据模型public StuModel(){this.init(null);}public void addStu(String sql){//根据用户输入的sql语句完成添加任务.}@Overridepublic String getColumnName(int column) {return (String)this.columnNames.get(column);}@Override//得到共有多少列public int getColumnCount() {//System.out.print("getColumnCount");//测试所用return this.columnNames.size();}@Override//得到共有多少行public int getRowCount() {return this.rowData.size();}@Override//得到某行某列的数据public Object getValueAt(int rowIndex, int columnIndex) { return ((Vector)this.rowData.get(rowIndex)).get(columnIndex);}}package com.test2;import java.awt.*;import java.awt.event.*;import java.sql.*;import javax.swing.*;public class StuAddDialog extends JDialog implements ActionListener{//定义我需要的swing组件JLabel jl1, jl2,jl3, jl4, jl5 ,jl6;JButton jb1,jb2;JTextField jtf1,jtf2,jtf3,jtf4,jtf5,jtf6;JPanel jp1,jp2,jp3;//构造函数 Frame代表父窗口口,title代表窗口的名字,model指定是模式窗口,还是非模式的窗口public StuAddDialog(Frame owner,String title,boolean model){super(owner,title, model); //调用父类构造方法,达到模式对话框效果jl1=new JLabel("学号");jl2=new JLabel("姓名");jl3=new JLabel("性别");jl4=new JLabel("年龄");jl5=new JLabel("籍贯");jl6=new JLabel("系别");jtf1=new JTextField();jtf2=new JTextField();jtf3=new JTextField();jtf4=new JTextField();jtf5=new JTextField();jtf6=new JTextField();jb1=new JButton ("添加");jb2=new JButton ("取消");jp1=new JPanel();jp2=new JPanel();jp3=new JPanel();//设置布局jp1.setLayout(new GridLayout(6,1));jp2.setLayout(new GridLayout(6,1));//添加组件jp1.add(jl1);jp1.add(jl2);jp1.add(jl3);jp1.add(jl4);jp1.add(jl5);jp1.add(jl6);jp2.add(jtf1);jp2.add(jtf2);jp2.add(jtf3);jp2.add(jtf4);jp2.add(jtf5);jp2.add(jtf6);jp3.add(jb1);jp3.add(jb2);this.add(jp1,BorderLayout.WEST);this.add(jp2,BorderLayout.CENTER);this.add(jp3,BorderLayout.SOUTH);//注册监听jb1.addActionListener(this);//展现this.setSize(300,200);this.setLocation(200, 300);this.setVisible(true);}@Overridepublic void actionPerformed(ActionEvent e) { if(e.getSource()==jb1){//希望添加StuModel temp =new StuModel();String sql="insert into student values (?,?,?,?,?,?)";String[]paras={jtf1.getText(),jtf2.getText(),jtf3.getText(),jtf4.getText(), jtf5.getText(),jtf6.getText()};if(!temp.updateStudent(sql, paras)){//提示JOptionPane.showMessageDialog(this, "添加失败");}//关闭对话框,关闭添加对话框this.dispose();}}}/*** 修改学生界面*/package com.test2;import java.awt.*;import java.awt.event.*;import java.sql.*;import javax.swing.*;public class StudentUpdateDialog extends JDialog implements ActionListener{//定义我需要的swing组件JLabel jl1, jl2,jl3, jl4, jl5 ,jl6;JButton jb1,jb2;JTextField jtf1,jtf2,jtf3,jtf4,jtf5,jtf6;JPanel jp1,jp2,jp3;//构造函数 Frame代表父窗口口,title代表窗口的名字,model指定是模式窗口,还是非模式的窗口public StudentUpdateDialog(Frame owner,String title,boolean model,StuModel sm,int rownum){super(owner,title, model); //调用父类构造方法,达到模式对话框效果jl1=new JLabel("学号");jl2=new JLabel("姓名");jl3=new JLabel("性别");jl4=new JLabel("年龄");jl5=new JLabel("籍贯");jl6=new JLabel("系别");jtf1=new JTextField();jtf2=new JTextField();jtf3=new JTextField();jtf4=new JTextField();jtf5=new JTextField();jtf6=new JTextField();//初始化数据jtf1.setText((String)sm.getValueAt(rownum, 0)); jtf1.setEditable(false);jtf2.setText((String)sm.getValueAt(rownum, 1)); jtf3.setText((String)sm.getValueAt(rownum, 2)); jtf4.setText(sm.getValueAt(rownum, 3)+"");jtf5.setText((String)sm.getValueAt(rownum, 4)); jtf6.setText((String)sm.getValueAt(rownum, 5));jb1=new JButton ("修改");jb2=new JButton ("取消");jp1=new JPanel();jp2=new JPanel();jp3=new JPanel();//设置布局jp1.setLayout(new GridLayout(6,1));jp2.setLayout(new GridLayout(6,1));//添加组件jp1.add(jl1);jp1.add(jl2);jp1.add(jl3);jp1.add(jl4);jp1.add(jl5);jp1.add(jl6);jp2.add(jtf1);jp2.add(jtf2);jp2.add(jtf3);jp2.add(jtf4);jp2.add(jtf5);jp2.add(jtf6);jp3.add(jb1);jp3.add(jb2);this.add(jp1,BorderLayout.WEST);this.add(jp2,BorderLayout.CENTER);this.add(jp3,BorderLayout.SOUTH);//注册监听jb1.addActionListener(this);//展现this.setSize(300,200);this.setLocation(200, 300);this.setVisible(true);}@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubif(e.getSource()==jb1){String sql ="update student setstuName=?,stuSex=?,stuAge=?,stuJg=?,stuDept=? where stuId=?";String[]paras={this.jtf2.getText(),jtf3.getText(),this.jtf4.getText(),this. jtf5.getText(),this.jtf6.getText(),this.jtf1.getText()};StuModel temp =new StuModel();temp.updateStudent(sql, paras);}}}第七十三讲: ADO 模型:在函数里需要传值,但是在调用时却不需要传值,那么就可以传入null值,在函数内部先if判断是否为null 如果不是再进行操作,为空的时候在进行为空的操作.或者第二种解决方法来自于: select * from student where 1=1;可以在传入的参数中为1 sql 语句改为select * from student where 1=?简而言之:还是第一个方法好。

Spring课堂笔记

Spring部分学习笔记讲师:梁建全liangjq@目录Spring部分学习笔记 (1)DAY01 (5)一、Spring框架的作用和好处 (5)二、Spring框架对Bean组件的管理 (5)1、使用方法： (5)2、Spring容器对Bean组件的管理 (5)3、Spring框架的IoC机制 (6)A.DI (依赖注入) (6)B.各种类型数据的注入 (7)C.IoC(Inverse of Controller,控制反转) (9)三、AOP概念 (9)1、什么是AOP? (9)2、AOP基本应用 (9)A.引入AOP开发包 (9)B.定义一个Bean组件(方面组件)，封装共通处理 (9)C.在applicationContext.xml中定义AOP配置 (9)3、AOP相关概念 (10)4、通知类型 (10)5、切入点表达式 (11)6、AOP练习完成记录用户操作日志示例。

(11)7、编写一个AOP示例，异常处理方面 (13)DAY02 (14)一、Log4j工具介绍 (14)1、体系结构 (14)2、消息级别 (14)二、Spring注解配置 (15)1、组件的自动扫描 (15)2、AOP注解标记 (15)3、(异常处理)案例重构 (15)4、XML和注解两种配置形式 (16)DAY03 (17)一、Spring对数据访问层的支持 (17)1、提供了事务管理 (17)2、提供了DAO实现支持 (17)3、如何整合JDBC技术 (17)4、如何整合Hibernate技术 (19)5、Spring整合Hibernate后，如何使用Hibernate中的Session对象 (21)二、Spring如何与Struts2框架整合 (22)1、添加Struts2框架 (22)2、编写Action，需要使用DAO组件采用DI方式注入 (22)3、Spring容器中定义Action组件，注入DAO (22)4、在struts.xml中定义Action组件和请求配置 (22)5、在web.xml中添加配置，在启动tomcat时，实例化Spring容器 (23)DAY04 (24)一、Spring与Struts2、Hibernate 整合 (24)1、SSH工作流程 (24)二、ssh开发步骤 (25)1、引入开发包 (25)2、编写实体类和映射文件hbm.xml(可以利用MyEclipse工具) (25)3、编写DAO组件 (26)4、在Spring配置文件中定义DAO,SessionFactory,DataSource按以下关系注入 (26)5、添加Struts2配置文件及控制器配置 (27)6、编写Action组件,需要使用Service或DAO时，采用名称匹配规则注入 (27)7、在struts.xml中添加Action组件配置（代码在5、中） (27)8、修改jsp，利用struts2标签完成显示 (27)9、修改web.xml，添加Listener配置，实例化Spring容器 (27)10、按ssh-2图示检查一下流程。

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 配置⽂件配置对象创建，配置属性注⼊<bean id="book" class="com.atguigu.spring5.Book"><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 配置⽂件中进⾏配置<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 值<property name="address"><null/></property>（2）属性值包含特殊符号<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();}}<bean id="userService" class="erService"><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 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 配置⽂件进⾏配置<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu"><property name="courses"><array><value>java 课程</value><value>数据库课程</value></array></property><property name="list"><list><value>张三</value><value>⼩三</value></list></property><property name="maps"><map><entry key="JAVA" value="java"></entry><entry key="PHP" value="php"></entry></map></property><property name="sets"><set><value>MySQL</value><value>Redis</value></set></property></bean>4、在集合⾥⾯设置对象类型值<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><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 集合注⼊提取<util:list id="bookList"><value>易筋经</value><value>九阴真经</value><value>九阳神功</value></util: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 id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName"></bean><bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>（2）根据属性类型⾃动注⼊<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType"></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、基于注解⽅式实现对象创建第⼀步引⼊依赖第⼆步开启组件扫描<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、开启组件扫描细节配置<context:component-scan base-package="com.atguigu" use-default- filters="false"><context:include-filter type="annotation"expression="org.springframework.stereotype.Controller"/></context:component-scan><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学习笔记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记录日志 (15)七、Spring注解配置 (16)7.1组件扫描功能 (16)7.2组件扫描的使用方法 (16)7.3注入注解标记使用方法 (17)7.4 AOP注解标记使用方法 (17)八、Spring对数据访问技术的支持 (19)8.1 Spring提供了统一的异常处理类型 (19)8.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 (37)11.1 Spring MVC的体系结构 (37)11.2 Spring MVC的工作流程 (37)11.3案例：简易登录（基于XML配置，不推荐使用） (37)11.4案例：修改11.3案例（基于注解配置，推荐使用） (39)十二、其他注意事项 (41)12.1 Spring的核心模块 (41)12.2表单中action属性的相对、绝对路径问题 (41)12.3用SSH重构NetCTOSS项目模块的步骤 (41)一、Spring概述我们学习Spring框架的最终目的是用它整合Struts2、Hibernate框架（SSH）。

韩顺平循序渐进学java从入门到精通课件笔记第三十五讲到第三十七

韩顺平循序渐进学java从入门到精通课件笔记第三十五讲到第三十七第三十五讲：Java异常处理在本节课中，我们将学习Java中的异常处理。

异常是在程序执行过程中出现的错误或异常情况。

Java提供了一套强大的异常处理机制，可以帮助我们更好地处理这些异常情况，使程序更加健壮和可靠。

1. 异常的概念和分类异常是指在程序运行过程中出现的错误或异常情况。

Java中的异常分为两种类型：受检异常（checked exception）和非受检异常（unchecked exception）。

- 受检异常：需要在代码中显式处理的异常，如IOException、SQLException等。

必须使用try-catch语句块或将异常抛出。

- 非受检异常：不需要在代码中显式处理的异常，如NullPointerException、ArrayIndexOutOfBoundsException等。

可以使用try-catch语句块处理，但不强制要求。

2. 异常处理的语法Java中的异常处理通过try-catch-finally语句块来实现。

try块用于包含可能会引发异常的代码，catch块用于捕获并处理异常，finally块用于定义无论是否发生异常都需要执行的代码。

```javatry {// 可能引发异常的代码} catch (ExceptionType1 e1) {// 处理ExceptionType1类型的异常} catch (ExceptionType2 e2) {// 处理ExceptionType2类型的异常} finally {// 无论是否发生异常都会执行的代码}```3. 异常处理的示例下面是一个简单的示例，演示了如何使用异常处理机制来处理除数为零的异常。

```javapublic class DivideByZeroExample {public static void main(String[] args) {int dividend = 10;int divisor = 0;try {int result = dividend / divisor;System.out.println("结果：" + result);} catch (ArithmeticException e) {System.out.println("除数不能为零！");}}}```在上面的示例中，我们首先定义了一个除数为零的情况，然后使用try块来执行除法运算。

spring学习课堂笔记

在JavaWeb项目中使用：
session:
request:
spring Bean对象初始化和销毁
在applicationContext.xml设置销毁和初始化
<bean init-method="init" destroy-method="destroy">
<property name="student3" ref="student3"/>
parent：在父对象中查找
使用容器加载多个配置文件
(1)数组方式：
new ClassPathXmlApplicationContext(new String[] {
(c)设置全局default-lazy-init="true"
整个配置文件中对象都实例化延迟
<beans ...
default-lazy-init="true">
</beans>
注意：在使用定时器的时候,不能使用lazy-init="true"
F支持ClassPath搜索器
classpath:applicationContext.xml
3、spring国际化
FileSystemXmlApplicationContext支持国际化
spring bean对象生命周期
通过lazy-init可以改变对象实例化时机
DI主要是IOC的一个实现
IUserDao iuserDao= new UserDaoImp();
对象依赖关系让容器管理，程序员不用关系类与类之间

(O管理)玩转实战教程(韩顺平)学习笔记

（O管理）玩转实战教程(韩顺平)学习笔记韩顺平—玩转oracle视频教程笔记一：Oracle认证，与其它数据库比较，安装oracle的卸载1.停止所有与ORACLE相关的服务。

2. 使用OUI（Oracle Universal Installer）卸载Oracle软件。

“开始”->“程序”->“Oracle-OraDb110g_home1|Oracle installation product|Universal installer.3.删除注册表内容。

运行regedit命令，删除下面内容：HKEY_LOCAL_MACHINE|SOFTWARE|ORACLE注册表键，删除此键。

HKEY_LOCAL_MACHINE|SYSTEM|CurrentControlSet|Services，删除Services键下所有以oracle为首的键。

HKEY_CLASSES_ROOT，删除此键下所有以Ora，Oracle，Orcl，EnumOra 为前缀的键。

HKEY_LOCAL_MACHINE|SOFTWARE|ODBC|ODBCINST.INI注册表键，删除了Microsoft ODBC FOR ORACLE注册表键以外的所有有Oracle字样的键值。

HKEY_LOCAL_MACHINE|SYSTEM|CurrentControlSet|Services，删除以Oracle或OraWeb为前缀的键。