[关闭]
@nextleaf 2018-10-11T09:27:25.000000Z 字数 6823 阅读 1031

2018-10-09 工作日志

jQuery AJAX Spring


上午

jQuery Ajax

通过HTTP请求加载远程数据。jQuery.AJAX 中文API 3.3.1

  1. //页面加载时给元素注册事件
  2. $(document).ready(function () {
  3. });
  4. //保存数据到服务器,成功时显示信息
  5. $.ajax({
  6. type: "POST",
  7. url: "some.php",
  8. data: "name=John&location=Boston",
  9. success: function(msg){
  10. alert( "Data Saved: " + msg );
  11. }
  12. });
  13. //请求 test.php 网页,传送2个参数,忽略返回值。
  14. $.get("test.php", { name: "John", time: "2pm" } );
  15. //显示 test.cgi 返回值(HTML 或 XML,取决于返回值),添加一组请求参数。
  16. $.get("test.cgi", { name: "John", time: "2pm" },
  17. function(data){
  18. alert("Data Loaded: " + data);
  19. });
  20. //请求 test.php 网页,忽略返回值
  21. $.post("test.php");
  22. //向服务器传递数据数组(同时仍然忽略返回值)
  23. $.post("test.php", { 'choices[]': ["Jon", "Susan"] });
  24. //使用 ajax 请求发送表单数据:
  25. $.post("test.php", $("#testform").serialize());
  26. //输出来自请求页面 test.php 的结果(HTML 或 XML,取决于所返回的内容)
  27. $.post("test.php", function(data){
  28. alert("Data Loaded: " + data);
  29. });
  30. //获得 test.php 页面的内容,并存储为 XMLHttpResponse 对象,并通过 process() 这个 JavaScript 函数进行处理
  31. $.post("test.php", { name: "John", time: "2pm" },
  32. function(data){
  33. process(data);
  34. }, "xml");
  35. //获得 test.php 页面返回的 json 格式的内容
  36. $.post("test.php", { "func": "getNameAndTime" },
  37. function(data){
  38. alert(data.name); // John
  39. console.log(data.time); // 2pm
  40. }, "json");
  41. /*
  42. load(url, [data], [callback])
  43. 载入远程 HTML 文件代码并插入至 DOM 中。
  44. 默认使用 GET 方式 - 传递附加参数时自动转换为 POST 方式。jQuery 1.2 中,可以指定选择符
  45. url:待装入 HTML 网页网址。
  46. data:发送至服务器的 key/value 数据。在jQuery 1.3中也可以接受一个字符串了。
  47. callback:载入成功时回调函数。
  48. */
  49. //加载 feeds.html 文件内容
  50. $("#feeds").load("feeds.html");
  51. //以 POST 形式发送附加参数并在成功时显示信息
  52. $("#feeds").load("feeds.php", {limit: 25}, function(){
  53. alert("The last 25 entries in the feed have been loaded");
  54. });

下午:

Struts2

Spring

Spring结构

Spring的使用步骤

Spring容器的特征

Spring 提供了两种不同类型的容器:

ApplicationContext 容器包括 BeanFactory 容器的所有功能,所以通常建议超过 BeanFactory。BeanFactory 仍然可以用于轻量级的应用程序,如移动设备或基于 applet 的应用程序,其中它的数据量和速度是显著

Spring容器创建对象方式:
默认单例模式:scope="singleton"(例如DAO)
原型模式:scope="prototype"(例如Action)

spring容器创建对象时机:
lazy-init=""指定是否延迟创建单例组件,只对单例对象有效

对象的初始化和销毁:
init-method="方法名",此方法会在Spring容器创建对象后自动调用
destroy-method="方法名",此方法会在Spring容器关闭时自动调用(此时使用AbstractApplicationContext接口)

Spring 容器使用依赖注入(DI)来管理组成一个应用程序的组件。这些对象被称为 Spring Beans


2018-10-10


Spring IOC

什么是IOC?
Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。
控制反转是spring的核心,控制反转把原先我们代码里面需要实现的对象创建、依赖的代码,反转给容器来帮忙实现。
对于spring框架来说,就是由spring来负责控制对象的生命周期和对象间的关系。
理解:
所有的类都会在spring容器中登记,告诉spring你是个什么东西,你需要什么东西,然后spring会在系统运行到适当的时候,把你要的东西主动给你,同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制,也就是说控制对象生存周期的不再是引用它的对象,而是spring。对于某个具体的对象而言,以前是它控制其他对象,现在是所有对象都被spring控制,所以这叫控制反转。

应用程序需要IoC容器来提供对象需要的外部资源;IoC容器注入应用程序某个它依赖的对象。

Spring IOC 实现原理:
IoC的一个重点是在系统运行中,动态的向某个对象提供它所需要的其他对象。这一点是通过DI(Dependency Injection,依赖注入)来实现的。
Java反射(reflection)机制允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性,DI就是通过反射来实现注入的。

Spring IOC的使用:
(1) 创建被依赖的组件(通常都是接口类型)

  1. import com.nl.springpracticaltraining.entity.Cost;
  2. import java.util.List;
  3. public interface ICostDao {
  4. void save(Cost cost);
  5. void update(Cost cost);
  6. void delete(int id);
  7. List<Cost> findAll();
  8. Cost findById(int id);
  9. }
  1. public class HibernateCostDao implements ICostDao {
  2. //实现接口方法略
  3. public void myinit(){
  4. System.out.println("初始化HibernateCostDao");
  5. }
  6. public void mydestroy(){
  7. System.out.println("销毁HibernateCostDao");
  8. }
  9. }

(2) 创建目标组件,并提供接收依赖组件的方式

  1. public class AddCostAction {
  2. //使用接口属性来封装
  3. private ICostDao iCostDao;
  4. //使用setter方式注入
  5. public void setiCostDao(ICostDao costDao) {
  6. System.out.println("使用setter方式注入");
  7. this.iCostDao = costDao;
  8. }
  9. /*
  10. //或者构造方式注入:
  11. public AddCostAction(ICostDao iCostDao) {
  12. this.iCostDao = iCostDao;
  13. System.out.println("实例化UpdateCostAction(构造方式注入)");
  14. }
  15. */
  16. public String execute(){
  17. System.out.println("资费修改Action.execute()");
  18. iCostDao.update(new Cost());
  19. return "success";
  20. }
  21. }

(3) 在applicationContext.xml中配置依赖组件和目标组件,以及他们的依赖关系

  1. <!--class可替换为其他技术的实现类,如JDBC,Hibernate-->
  2. <bean id="costDao" class="com.nl.springpracticaltraining.dao.HibernateCostDao" scope="singleton" lazy-init="default"
  3. init-method="myinit" destroy-method="mydestroy">
  4. <!--<property name="dataSource" ref="ds"/>-->
  5. </bean>
  6. <!--Action组件使用prototype方式创建对象-->
  7. <bean id="addCostAction" class="com.nl.springpracticaltraining.action.AddCostAction" scope="prototype">
  8. <!--使用接口属性来封装,使用setter方式注入,ref依赖的组件ID-->
  9. <property name="iCostDao" ref="costDao"/>
  10. </bean>
  11. <bean id="updateCostAction" class="com.nl.springpracticaltraining.action.UpdateCostAction" scope="prototype">
  12. <!--使用接口属性来封装,使用构造方式注入,index,构造方法的参数位置,ref=依赖的组件ID-->
  13. <constructor-arg index="0" ref="costDao"/>
  14. </bean>

(4) 使用Spring容器创建目标组件时,依赖属性就已经有了注入的值了.

  1. @Test
  2. public void updatec() {
  3. ApplicationContext context = new ClassPathXmlApplicationContext(conf);
  4. UpdateCostAction updateCostAction = (UpdateCostAction) context.getBean("updateCostAction");
  5. System.out.println(
  6. updateCostAction.execute()
  7. );
  8. }

数据类型的注入:
(1)组件(JavaBean)类型的注入

  1. <property name="属性名" ref="组件的ID" />

(2)基本类型的注入

  1. <property name="属性" value="值" />

(3) 集合类型(List,Set,Map,Properties)注入

  1. <!--数据类型的注入-->
  2. <bean id="personDemo" class="com.nl.springpracticaltraining.entity.PersonDemo">
  3. <property name="name" value="黄昭鸿"/>
  4. <property name="age" value="16"/>
  5. <property name="list">
  6. <list>
  7. <value>g1</value>
  8. <value>g2</value>
  9. <value>g13</value>
  10. <value>g14</value>
  11. <value>g15</value>
  12. <value>g16</value>
  13. <value>g17</value>
  14. </list>
  15. </property>
  16. <property name="set">
  17. <set>
  18. <value>b1</value>
  19. <value>b2</value>
  20. <value>b3</value>
  21. <value>b4</value>
  22. </set>
  23. </property>
  24. <property name="map">
  25. <map>
  26. <entry key="g1" value="789456123"/>
  27. <entry key="g2" value="963852741"/>
  28. <entry key="g13" value="321654987"/>
  29. <entry key="g14" value="8524631798"/>
  30. <entry key="g15" value="7539514682"/>
  31. </map>
  32. </property>
  33. <!--Properties类型-->
  34. <property name="events">
  35. <props>
  36. <prop key="2008">与谁在哪里干了什么事</prop>
  37. <prop key="2009">与谁在哪里干了什么事</prop>
  38. <prop key="2010">与谁在哪里干了什么事</prop>
  39. <prop key="2011">与谁在哪里干了什么事</prop>
  40. <prop key="2012">与谁在哪里干了什么事</prop>
  41. <prop key="2013">与谁在哪里干了什么事</prop>
  42. <prop key="2014">与谁在哪里干了什么事</prop>
  43. <prop key="2015">与谁在哪里干了什么事</prop>
  44. </props>
  45. </property>
  46. </bean>

注解配置

注解使用的规则
(1)注解需要依附于类,属性,方法
(2)基本语法 "@注解名"

Spring中如何使用注解配置组件
(1) 在applicationContext-annotation.xml的beans标签下,开启对注解的自动扫描

  1. <context:component-scan base-package="com.nl" />

开启后,当Spring容器初始化时,它会自动的扫描这个包下所有类中的注解,并将注解配置过的bean纳入Spring容器中,当程序执行时,就可以使用Spring容器来创建这个bean了

(2) 使用注解配置bean
a, 在类上使用注解,标识该类是一个组件,它将被Spring容器管理
@Controller 用于标识Action组件
@Service 用于标识一个业务组件
@Repository 用于标识DAO组件
@Component 用于标识其他的通用组件

b, 在类上使用注解,标识对象的创建方式
@Scope("singleton")

c, 在属性/set方法/构造器上标识依赖的组件

标识属性(@Resource)
//Spring会自动匹配类型并注入,如果找不到类型会报错,如果找到的类型多余一个也会报错

  1. @Resource
  2. private ICostDao costDao;

  1. //使用id引用具体的某一个组件
  2. @Resouce(name="jdbcCostDao")
  3. private ICostDao costDao

标识属性(@AutoWired)

  1. @AutoWired
  2. @Qualifier("hibernateCostDao")
  3. private ICostDao costDao

标识set方法

  1. @Resource(name="jdbcCostDao")
  2. public void setCostDao(ICostDao dao){
  3. }

  1. @Autowired
  2. @Qulifier("jdbcCostDao")
  3. public void setCostDao(ICostDao dao){
  4. }

标识构造器

  1. @Autowired
  2. public AddCostAction(ICostDao dao){
  3. }

2018-10-09

image_1cpcln62o1ihofsb11qroo310k7n.png-27.4kB
image_1cpclng7n1ri91cj0r9s126r1jh614.png-30.1kB


2018-10-10

image_1cpgbn0ho179oa4shi9d4aol19.png-25.2kB
image_1cpgbn8sq1ndejqv161sbgceo9m.png-53.1kB


添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注