spring学习

1. 表现层：数据的显示和录入
2.页面1－－》表现模型2－－》控制器3(Struts1.2.3)－－》业务模型4（Service层普通类）－－》数据模型DAO层5（数据持久层Hibernate）－－》数据库6

3.Spring多个框架的集合：
（1）：（Spring Core）对象容器:创建对象，初始化！
（2）：（Spring AOP）业务逻辑支持
（3）：（Spring DAO）控制事物（操作数据库）
（4）：（Spring Context）工具中心（国际化）
（5）：（Spring Web）WEB
（6）：（Spring Web MVC）框架
（7）：（Spring ORM）整合三大框架

在用ssh(Struts+Spring+Hibernate)实现的mvc模式中Spring是作为连接Struts和Hibernate的控制层。

与Spring框架相关的概念有以下：

轻量级：轻量级是针对重量级容器(EJB)来说的，Spring的核心包不到1M大小，而使用Spring的核心包所需的资源也很小，所以可以在小型设备中使用。

非侵入性：所有的框架都是提供大量的功能供用户去使用，从而简化开发时间和成本，但由于大量的使用了框架的API，使应用程序和框架发生了大量的依赖性，无法从框架中独立出来，更加无法使程序组件在其他程序中使用，这样的框架叫做入侵式的框架，而Spring目标是一个非入侵式的服务框架。

容器：容器就是一个帮助你把原来自行编写程序去管理对象关系的工作转移给容器来做。Spring提供了容器功能，容器可以管理对象的生命周期、对象与对象之间的关系、你可以通过编写XML来设置对象关系和初始值，这样容器在启动之后，所有的对象都直接可以使用，不用编写任何编码来产生对象。

IOC/DI：Spring最核心的概念就是IOC(反转控制)，而他的另一个名字就是DI(依赖注入)；使用Spring，你不必在程序中维护对象的依赖关系，只要在xml中设定即可，Spring容器会自己根据相关的配置去产生他们之间的关系，所有的关系都是在容器运行的时候注入的，而他们本身是没有关系的。打个比方：比如张三和李四，之前是没有任何关系的两个对象，但当他俩进入班级这个容器中后，班级这个容器就将他俩赋予了同学的关系。这样的做法就是用容器去赋予对象之间的关系，而不是对象本身之间来创建关系。这样做的好处显然实现了松偶合。

AOP(Aspect Oriented Programming面向切面/方面编程)：Spring最被人重视的另一个方面就是对AOP的支持，AOP是Spring支持的一个子容器。在一个服务流程中插入与业务逻辑无关的系统服务逻辑(如：Logging登录、Security安全等)，而把这些独立出来设计成一个对象，这样的对象称为Aspect。打个比方：做一次环球旅行，在旅行途中要经过若干国家的海关关口办理出入境手续，这样的一个一个的关口就是整个旅行流程中的一个一个的Aspect。

4.Spring进行数据事物操作依赖CGLIB包
5.Ioc:Inversion of control反转控制
6.Ioc模式：又称DI，即Dependency Injection，叫做依赖注入,Spring提供三种注入方式(构造器，setter方法，混合注入 )。(属性赋值)

7.  构造器注入：ApplicationContext ctx=new FileSystemXmlApplication("./config.config.xml配置文件的绝对路径");
            User user=(User)ctx.getBean("配置文件id");
    <bean id="userBean" class="i./project.beans.User">
<constructor-arg index="0 ">
<value>Janet </value>
</constructor-arg>
<constructor-arg index="1">
<value>88888888</value>
</constructor-arg>
</bean>

8.Set方法注入：严重需要无参构造器，即调用默认构造器创建实例(在调用new instanceof()方法创建实例的时候会调用默认的构造器，如果没有则会报错！)。
<beans>
<bean id="userBean" class="./project.beans.User">
<property name="userName">
<value>Eric</value>
</property>
<property name="password">
<value>12345678</value>
</property>
</bean>
</beans>
9.混合注入：不需要默认构造器, 如果两种方法同时注入同一个属性，后面的会覆盖前面的,最后取值如下：138
<beans>
<bean id="userBean" class="./project.beans.User">
<property name="userName">
<value>88</value>
</property>
<constructor-arg index="0">
<value>138</value>
</constructor-arg>
</bean>
</beans>
10.Bean初始化：初始化方法和初始化接口(初始化接口优先级高于初始化方法)（直接初始化－－》构造器－－》set方法－－》初始化接口－－》初始化方法）

11.List,Set,（Map,Properties配置必须有key）集合的注入,Properties两个值都是String类型的
<bean id="userBean3" class="first.bean.User">
<property name="property">
<list>
<value>ning</value>
<value>fang</value>
<value>fen</value>
</list>
</property>
</bean>

User user = (User) ac.getBean("userBean3");
Properties p = user.getProps();
Set<Object> keys = p.keySet();
for (Object key : keys) {
System.out.println(key + ":" + p.get(key));
}

<bean id="userBean4" class="first.bean.User">
<property name="ningset">
<set>
<value>nin</value>
<value>fan</value>
<value>fe</value>
</set>
</property>
</bean>

<bean id="userBean5" class="first.bean.User">
<property name="fenMap">
<map>
<entry key="1">
<value>n</value>
</entry>
<entry key="2">
<value>ni</value>
</entry>
<entry key="3">
<value>nin</value>
</entry>
</map>
</property>
</bean>

      User user = (User) ac.getBean("userBean5");
Map map = user.getFenMap();
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key + ":" + map.get(key));
}

<bean id="userBean6" class="first.bean.User">
<property name="props">
<props>
<prop key="1">n</prop>
        <prop key="2">ni</prop>
<prop key="3">nin</prop>
<prop key="4">ning</prop>
</props>
</property>
</bean>

12.基本数据类型配置
     <bean id="userBean7" class="first.bean.User">
<property name="age">
<value type="java.lang.String">12</value>
</property>
</bean>

13.<bean id="userBean8" class="first.bean.User">
<property name="productName">
<value>basketball</value>
</property>
<property name="productPrice">
<value type="double">36.0</value>
</property>
</bean>

<bean id="userBean9" class="first.bean.Client">
<property name="clientName">
<value>ning</value>
</property>
<property name="clientProduct">
<ref bean="userBean8" />
</property>
<property name="birthday">
<ref bean="date" />
</property>
</bean>
<bean id="date" class="java.util.Date"></bean>
      Client user = (Client) ac.getBean("userBean9");
System.out.println(user.getClientName()
+ user.getClientProduct().getProductName()
+ user.getClientProduct().getProductPrice());
System.out.println(user.getBirthday());

4.   <bean id="userBean10" class="first.bean.User" singleton="true">
<property name="userage">
<value type="int">80</value>
</property>
<property name="username">
<null></null>
</property>
</bean>
User user = (User) ac.getBean("userBean10");
User user1 = (User) ac.getBean("userBean10");
System.out.println(user.getUserage+user1.gerUserage);
     user.setUserage(81);
System.out.println(user.getUserage+user1.gerUserage);

15.初始化方法调用的方法是默认的无参的。

16.Spring国际化： (lang=true)获取报头，读取配置文件（Struts国际化）
以下xml文件配置不能随便修改（Spring:spring-config.xml）
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>sencond.resource.Tareana</value>
</list>
</property>
</bean>
</beans>
ApplicationContext ctx = new FileSystemXmlApplicationContext(
"./sencond/config/spring-config.xml");
Object[] paramList = { "ning", "2008-07-02" };
Locale locale = Locale.ENGLISH;
String key = "userinfo";
String userinfo = ctx.getMessage(key, paramList, locale);
System.out.println(userinfo);
                                      
17.Spring事件模型（Event）(事件触发者，事件响应者，事件本身（事件定义），事件广播通道)
         流程：  =>事件定义（extends ApplicationEvent)
                        => 事件响应(implements ApplicationListener)
                        =>  配置事件（<bean id="listener1" class="sencond.event.Listener"></bean>）：如果多个响应着则依次触发
                        =>事件触发(applicationContext.publishEvent(event))

事件定义：(必须继承ApplicationEvent指定事件源super(ning))
public class EricEvent extends ApplicationEvent {
public EricEvent(Object ning) {
super(ning);
}
}

事件响应者：(实现ApplicationEvent接口，实现相应的接口方法)
public class Receiver implements ApplicationListener {
public void onApplicationEvent(ApplicationEvent event) {
//判断事件类型(事件定义EricEvent)
if (event instanceof EricEvent) {
//对各种事件的处理
System.out.println(event.toString());
}
}
}

事件触发者：(创建事件实例，调用ApplicationContext.publishEvent(事件实例))
EricEvent event = new EricEvent( "哇哈哈！" );
applicationContext.publishEvent(event);

config.xml配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="listener1" class="sencond.event.Listener"></bean>
<bean id="listener2" class="sencond.event.Listener2"></bean>
</beans>

如果没有配置事件接受者或事件，会如何？(不报错， 但没效果)
报错？
不 报错，但没效果？
程序完全正常？

如果对于同一种事件，有多个响应者会如何？(依次触发多个)
只触发第一个？
依次触发多个？
同时触发多个？  

18.AOP:Aspect-Oriented Programming 面向切面编程或面向方面的编程
        切面(Aspect)： 一个程序中有一个主业务逻辑，还有很多附加业务逻辑，要求交叉执行，但是代码分开（注册中的检查用户名是否可用和插入用户数据两个切面组成）？？
       连接点（JoinPoint）：在插入前要求打印开始插入，在插入数据后打印 插入成功，在这之间就存在着连接点。即是切面上的点？（按需求是否有要求要连接的）
       通知（ Advice）：决定了要切入什么样的代码和位置。（附加业务逻辑）
       切入点（Pointcut）:决定对于那个连接点使用什么样 的通知

业务流程: （1）检查用户名是否存在（切面）－》（连接点）－－》（通知）
                                                                   ｜切入点｜
          （2）插入用户数据（切面）－》（连接点）－－》（通知）

19.引入（Intorduction）：切入的动作.
    目标对象：
    代理：
    织入：

20.前置通知，返回后通知，抛出异常通知，后通知，环绕通知

21.JAVA动态代理（机制）：调用者（逻辑类）－－》（代理类）－－》（代理下属：即是过程处理器）－－》  被调用者（业务逻辑类）

22.advice（通知）是你想向别的程序内部不同的地方注入的代码。
   pointcut（切入点）定义了需要注入advice的位置，通常是某个特定的类的一个public方法。
advisor（通知）是pointcut和advice的装配器，是将advice注入主程序中预定义位置的代码。

23.Spring事物DAO（Spring进行数据事物操作依赖CGLIB包）:不需要任何配置，直接使用接口（Datasource类   JdbcTemplate类）

24.数据库：正式表空间和临时表空间（提交前其它用户不可读）

25.JdbcTemplate

26.事务：编程式(代理)和申明式（代码简单，可维护性和可扩展性强在每个方法调用前调用CGLI）两者控制事务的力度不同，编程可以是控制在每一行，而申明则只能是每个方法

27.queryForMap的使用只返回一条数据可以有多个字段

28. HibernateTemplate

29.Spring-->hibernate:datasource ,sessionfactory,hibernateTemplate,transactionManager,事务代理，userDao,userService
   Spring-->struts:truts初始化spring(<plug-in/插件>)－－》

      
30.每个包存放自己的配置文件，（超大型项目的时候）
     把文件存放在同一个目录分模块存放模块的配置文件方便管理员修改查看（中，小型项目）

31.在sturts中引用多个配置文件只需要在XML配置里面以逗号分开添加配置文件路径，struts这种多配置的文件的方式其实是一个大的文件，他们之间可以互相调用，而不用import进来。

33.Spring(common):<import resource="xml配置文件的绝对路径"/>

34.看文档建包，
     搭建环境，配置Web-xml文件，把struts配置文件路径配置好
     建库建表－－》javaBean(实体)exends ActionForm－－》Dao方法－－》Service调用 Dao方法－－》控制器extends Action实现execute() 强转Form直接调用Service方法并捕获异常－－》（配置配置文件） dao层依赖hibernateTemplate service依赖dao 

35.控制器的 name=“path” type="类路径"

36.tomcat内存溢出pernGen space 重启tomcat或修改内存tomcat------>>>>> 配置文件修改

37.XML JAVA的发射机制(创建对象实例和给属性赋值)