翻译:Eclipse开发: Struts 2 + Spring 2 + JPA + AJAX

Java Web框架篇之Spring 为什么要有Spring(IoC) Web发展的几个阶段 (1)初级阶段:使用Model1(JSP+JavaBean)/Model2(Jsp+Servlet+JavaBean)/三层模型(表示层(JSP/Servlet)+业务逻辑层+持久化层)进行开发; (2)中级阶段:使用EJB进行分布式应用开发,忍受重量级框架带来的种种麻烦; (3)高级阶段:使用Spring春天带给我们的美好,但是还要忍受很... 阅读详情
 

本文翻译自:http://cwiki.apache.org/S2WIKI/struts-2-spring-2-jpa-ajax.html

来自Struts2 WiKi上的一篇文章,讲解如何在Eclipse + WTP中进行Spring2, Struts2, JPA的整合开发。很基础的说,希望对于想学习SSH的人能有一定的帮助。我在翻译的过程中,也尝试使用MyEclipse来进行整合开发。但由于水平有限,翻译质量不敢恭维,有何错误地方,请尽量告知。谢谢!

晚上调试成功了,现在把几点需要注意的地方说一下!希望你也能顺利的通过调试,有什么问题欢迎大家一起讨论。

 

本指南演示了如何在Eclipse中配置Struts2,并让它与Spring2,Java Persistence API(使用Hibernate)和Struts2 Ajax 标签一起工作。

注意:按指南一步一步来需要Struts2.0.3或更高版本

 

Show me the code

你可以在 zipped Eclipse project下载源代码,必需的依赖库在/WebContent/WEB-INF/lib目录下,需要导入到Eclipse中。

Prerequisites

 

Tomcat

首先要安装好Tomcat,如果在安装的时候遇到任何问题,请查看Tomcat的安装指南

 

MySql

安装并配置MySQL。创建一个名为“quickstart”的数据库,并运行下面脚本来创建“Person”表。后面在applicationContext.xml里,我们将使用"root"数据库用户名和密码,记得用你自己的数据库设置来替换它们。


   
CREATE   TABLE   ' quickstart ' . ' Person '  (
  
' id '   INTEGER  UNSIGNED  NOT   NULL  AUTO_INCREMENT,
  
' firstName '   VARCHAR ( 45 )  NOT   NULL ,
  
' lastName '   VARCHAR ( 45 )  NOT   NULL ,
  
PRIMARY   KEY ( ' id ' )
)
ENGINE 
=  InnoDB;

 注:上面的DDL需要保存在文件中,然后在MySQL中导入。我直接复制然后在查询分析器中执行失败

创建Eclipse项目

  1. 打开Eclipse,我是认真的,你必须打开Eclipse
  2. 点击File -> New -> Project. 选择"Dynamic Web Project"并点击下一步(注:如果使用MyEclipse,这里不太一样)
  3. 输入项目名,这里我使用"quickstart"。这个项目将要在Tomcat中运行,所以我们需要为它创建应用服务器配置
    1. 在"Target Runtime"下面点击"New",选择"Apache Tomcat5.5"并点击下一步
    2. 输入Tomcat的安装路径并选择一下已安装的JRE(需要1.5)
  4. 现在你应该回到了项目创建向导,并且Tomcat是你的Target Runtime。点击下一步,选择"Dynamic Web Module"和"Java"facets,最后点"finish"。

(上面讲的都是Eclipse WTP中的配置,如果使用MyEclipse请自行修正)

 

库依赖关系

你的项目应该包含"src","build"和"WebContent"目录。我们把所有必需的jar文件放在"/WebContent/WEB-INF/lib"目录下。请复制它们到${workspace}/quickstart/WebContent/WEB-INF/lib目录。jar文件名的版本号已经被去除了!

JarFrom
xwork.jarStruts 2
struts2-api.jarStruts 2
struts2-core.jarStruts 2
struts2-Spring-plugin.jarStruts 2
ognl.jarStruts 2
freemarker-2.3.4.jarStruts 2
mysql-connector-java.jarMySql JDBC Driver
spring.jarSping 2.0
antlr.jarHibernate Core
asm.jarHibernate Core
asm-attrs.jarHibernate Core
cglib.jarHibernate Core
dom4j.jarHibernate Core
jdbc2_0-stdext.jarHibernate Core
ehcache.jarHibernate Core
hibernate3.jarHibernate Core
xml-apis.jarHibernate Core
commons-collections.jarHibernate Core
ejb3-persistence.jarHibernate Annotations
jta.jarHibernate Annotations
hibernate-annotations.jarHibernate Annotations
hibernate-entitymanager.jarHibernate Entity Manager
javassist.jarHibernate Entity Manager
jboss-archive-browsing.jarHibernate Entity Manager

右击项目点“刷新”,通知Eclipse我们加入了很多的jar文件。

我使用Struts2.0.6, Spring2.0.3, Hibernate3.2。struts2-api.jar找不到,没有也可以运行成功;Hibernate Annotations和Hibernate Entity Manager需要在Hibernate的主页上下载,不包括在Core里面;另外jta.jar和javassist.jar在Hibernate Tools里面,同样要下载;最后,上面列表并缺少一个包,因为Hibernate3.2对此有一点小小的修改,你需要把Hibernate Annotations里面的hibernate-commons-annotations.jar拷贝进来。

 

领域模型

我们的领域模型只有一个简单的"Person"类,它包含少量的实例变量。

  1. 创建一个新类并命名为"Person",然后输入"quickstart.model"作为包名。
  2. 添加"id"(int), "firstName"(String)和"lastName"(String)三个实例变量,并为它们加上setter/getter方法。
  3. 为你的类加上"@Entity"annotation,给"id" 加上 "@Id"和"@GeneratedValue" 注解

你的类如下:

Person.java

   
package  quickstart.model;

import  javax.persistence.Entity;
import  javax.persistence.GeneratedValue;
import  javax.persistence.Id;

@Entity
public   class  Person {
    @Id
    @GeneratedValue
    
private  Integer id;
    
private  String lastName;
    
private  String firstName;

    
public  String getFirstName() {
        
return  firstName;
    }

    
public   void  setFirstName(String firstName) {
        
this .firstName  =  firstName;
    }

    
public  String getLastName() {
        
return  lastName;
    }

    
public   void  setLastName(String lastName) {
        
this .lastName  =  lastName;
    }

    
public  Integer getId() {
        
return  id;
    }

    
public   void  setId(Integer id) {
        
this .id  =  id;
    }
}

@Entity让JPA服务Provider知道这个类可以被持久化。@Id标识"id"域为这个类的主键,@GeneratedValue使id域被提供者(Hibernate)自动生成。类和实例变量默认都被映射到同名的表和列上,详细情况请查看JPA文档。

 

Person service.

我们现在来写对"Person"对象进行CRUD操作的类。

  1. 创建一个接口,命名为"PersonService",包名为"quickstart.service"
PersonService.java

   
package  quickstart.service;

import  java.util.List;

import  quickstart.model.Person;

public   interface  PersonService {
    
public  List < Person >  findAll();

    
public   void  save(Person person);

    
public   void  remove( int  id);

    
public  Person find( int  id);
}

    

     2.  创建一个类,命名为"PersonServiceImpl",包名为"quickstart.service"

PersonServiceImpl.java
package  quickstart.service;

import  java.util.List;

import  javax.persistence.EntityManager;
import  javax.persistence.PersistenceContext;
import  javax.persistence.Query;

import  org.springframework.transaction.annotation.Transactional;

import  quickstart.model.Person;

@Transactional
public   class  PersonServiceImpl  implements  PersonService {
    
private  EntityManager em;

    @PersistenceContext
    
public   void  setEntityManager(EntityManager em) {
        
this .em  =  em;
    }

    @SuppressWarnings(
" unchecked " )
    
public  List < Person >  findAll() {
        Query query 
=  getEntityManager().createQuery( " select p FROM Person p " );
        
return  query.getResultList();
    }

    
public   void  save(Person person) {
        
if  (person.getId()  ==   null ) {
            
//  new
            em.persist(person);
        } 
else  {
            
//  update
            em.merge(person);
        }
    }

    
public   void  remove( int  id) {
        Person person 
=  find(id);
        
if  (person  !=   null ) {
            em.remove(person);
        }
    }

    
private  EntityManager getEntityManager() {
        
return  em;
    }

    
public  Person find( int  id) {
        
return  em.find(Person. class , id);
    }

}
@PersistenceContext会让Spring在实例化的时候给服务注入一个EntityManager。@PersistenceContext注解可以放在实例变量,或者setter方法前面。如果一个类被注解为@Transactional,Spring将会确保类的方法在运行在一个事务中。

JPA 配置

  1. 在"src"目录下创建一个"META-INF"目录
  2. 在"META-INF"目录下创建一个名为"persistence.xml"的文件。
persistence.xml

    
< persistence  xmlns ="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi
="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation
="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
    version
="1.0" >
    
< persistence-unit  name ="punit" >
    
</ persistence-unit >
</ persistence >

JPA configuration can be set on this file. On this example it will be empty because the datasource configuration will be on the Spring configuration file. JPA的配置信息可以在这个文件中设置。本例中该文件为空,因为数据源(datasource)配置放在Spring的配置文件中。

 

Spring

  1. 更新/WebContent/WEB-INF/web.xml文件为以下内容:
web.xml
<? xml version="1.0" encoding="UTF-8" ?>
< web-app  id ="person"  version ="2.4"  xmlns ="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi
="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation
="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" >
    
< display-name > person </ display-name >
    
< filter >
        
< filter-name > struts2 </ filter-name >
        
< filter-class >
            org.apache.struts2.dispatcher.FilterDispatcher
        
</ filter-class >
    
</ filter >

    
< filter-mapping >
        
< filter-name > struts2 </ filter-name >
        
< url-pattern > /* </ url-pattern >
    
</ filter-mapping >


    
< welcome-file-list >
        
< welcome-file > index.jsp </ welcome-file >
    
</ welcome-file-list >

    
< listener >
        
< listener-class >
            org.springframework.web.context.ContextLoaderListener
        
</ listener-class >
    
</ listener >
</ web-app >
这会使容器将所有请求转发给Struts的"FilterDispatcher"类。"index.jsp"被设为主页,Spring的"ContextLoaderListener"被配置为listener(监听器)
  1. 在/WebContent/WEB-INF目录下创建一个名为"applicationContext.xml"的文件,内容如下:
applicationContext.xml
<? xml version="1.0" encoding="UTF-8" ?>
< beans  xmlns ="http://www.springframework.org/schema/beans"
    xmlns:xsi
="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop
="http://www.springframework.org/schema/aop"
    xmlns:tx
="http://www.springframework.org/schema/tx"
    xsi:schemaLocation
="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"
>

    
< bean
        
class ="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"   />

    
< bean  id ="personService"  class ="quickstart.service.PersonServiceImpl"   />

    
< bean  id ="entityManagerFactory"
        class
="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" >
        
< property  name ="dataSource"  ref ="dataSource"   />
        
< property  name ="jpaVendorAdapter" >
            
< bean
                
class ="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" >
                
< property  name ="database"  value ="MYSQL"   />
                
< property  name ="showSql"  value ="true"   />
            
</ bean >
        
</ property >
    
</ bean >

    
< bean  id ="dataSource"
        class
="org.springframework.jdbc.datasource.DriverManagerDataSource" >
        
< property  name ="driverClassName"  value ="com.mysql.jdbc.Driver"   />
        
< property  name ="url"  value ="jdbc:mysql://localhost/test"   />
        
< property  name ="username"  value ="root"   />
        
< property  name ="password"  value ="root"   />
    
</ bean >

    
< bean  id ="transactionManager"
        class
="org.springframework.orm.jpa.JpaTransactionManager" >
        
< property  name ="entityManagerFactory"  ref ="entityManagerFactory"   />
    
</ bean >

    
< tx:annotation-driven  transaction-manager ="transactionManager"   />

    
< bean  id ="personAction"  scope ="prototype"
        class
="quickstart.action.PersonAction" >
        
< constructor-arg  ref ="personService"   />
    
</ bean >
</ beans >
注意"personAction"bean的"class"属性被设为Action类的名字,并且"personService"bean会作为参数传递到action的构造器中。改变"dataSource"Bean的"url", "username"和"passwrod"属性为你数据库的值。更多beans设置的细节,请参看Spring的文档。"scope"是Spring2新增的属性,它意味着Spring会在该类型的对象被请求时创建一个新的PersonAction对象。在Struts2里,一个新的action对象被创建,用来为每个请求服务,这就是我们为什么需要scope="prototype"。

Struts

 现在我们需要创建一个简单的Struts action,它封装了PersonServices的方法。并且我们配置Struts使用Spring作为对象工厂。

  1. 打开新建类对话框,输入"PersonAction"作为类名,包名为"quickstart.action",内容如下:
PersonAction.java

   
package  quickstart.action;

import  java.util.List;

import  quickstart.model.Person;
import  quickstart.service.PersonService;

import  com.opensymphony.xwork2.Action;
import  com.opensymphony.xwork2.Preparable;

public   class  PersonAction  implements  Preparable {
    
private  PersonService service;
    
private  List < Person >  persons;
    
private  Person person;
    
private  Integer id;

    
public  PersonAction(PersonService service) {
        
this .service  =  service;
    }

    
public  String execute() {
        
this .persons  =  service.findAll();
        
return  Action.SUCCESS;
    }

    
public  String save() {
        
this .service.save(person);
        
this .person  =   new  Person();
        
return  execute();
    }

    
public  String remove() {
        service.remove(id);
        
return  execute();
    }

    
public  List < Person >  getPersons() {
        
return  persons;
    }

    
public  Integer getId() {
        
return  id;
    }

    
public   void  setId(Integer id) {
        
this .id  =  id;
    }

    
public   void  prepare()  throws  Exception {
        
if  (id  !=   null )
            person 
=  service.find(id);
    }

    
public  Person getPerson() {
        
return  person;
    }

    
public   void  setPerson(Person person) {
        
this .person  =  person;
    }
}

看,我的action是一个简单的POJO!

"Preparable"接口指示Struts去调用"prepare"方法,如果"PrepareInterceptor"被应用在action上(默认就是这样子的)。action的构造器有一个"PersonService"参数,在action被实例化的时候Spring会负责注入。

 

  1. 在"src"目录下创建一个名为"struts.xml"的文件,内容如下:
struts.xml

    
<? xml version="1.0" encoding="UTF-8"  ?>
<! DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd"
>
< struts >
    
< constant  name ="struts.objectFactory"  value ="spring"   />
    
< constant  name ="struts.devMode"  value ="true"   />

    
< package  name ="person"  extends ="struts-default" >

        
< action  name ="list"  method ="execute"  class ="personAction" >
            
< result > pages/list.jsp </ result >
            
< result  name ="input" > pages/list.jsp </ result >
        
</ action >

        
< action  name ="remove"  class ="personAction"  method ="remove" >
            
< result > pages/list.jsp </ result >
            
< result  name ="input" > pages/list.jsp </ result >
        
</ action >

        
< action  name ="save"  class ="personAction"  method ="save" >
            
< result > pages/list.jsp </ result >
            
< result  name ="input" > pages/list.jsp </ result >
        
</ action >
    
</ package >

</ struts >

设置"struts.objectFactory"为"spring"会强制Struts使用Spring来实例化action,并注入所有定义在applicationContext.xml中的依赖关系。每个action别名的"class"属性被设置为"personAction",这也就是我们在applicationContext.xml中定义的PersonAction bean。要让Struts与Spring一起工作,我们仅仅需要做上面这点事情。

 

页面设计

我们只有两个页面,"index.jsp"和"list.jsp"。"list.jsp"返回数据库中所有person的列表。我们把这个列表放到一个不同的页面上,是因为我们将要添加一点ajax来改进它。

  1.  在/WebContent/pages目录下创建一个名为"list.jsp" 的新文件,它的内容如下:
list.jsp
<% @ taglib prefix = " s "  uri = " /struts-tags " %>

< p > Persons </ p >
< s:if  test ="persons.size > 0" >
    
< table >
        
< s:iterator  value ="persons" >
            
< tr  id ="row_<s:property value=" id" /> ">
                
< td >
                    
< s:property  value ="firstName"   />
                
</ td >
                
< td >
                    
< s:property  value ="lastName"   />
                
</ td >
                
< td >
                    
< s:url  id ="removeUrl"  action ="remove" >
                        
< s:param  name ="id"  value ="id"   />
                    
</ s:url >
                    
< s:a  href ="%{removeUrl}"  theme ="ajax"  targets ="persons" > Remove </ s:a >
                    
< s:a  id ="a_%{id}"  theme ="ajax"  notifyTopics ="/edit" > Edit </ s:a >
                
</ td >
            
</ tr >
        
</ s:iterator >
    
</ table >
</ s:if >
上面代码呈现了一个表格,每行代表一个Person,包含first name,last name,以及一个链接用来删除person,一个链接用来编辑person。删除链接有一个"targets"属性,设置为"persons",表示当用户点击它时,一个异步的请求会被传递给"remove" action(struts.xml配置"remove"指向PersonAction的 remove方法),传递person  id作为参数。
注意list.jsp是在pages目录下,如果你放在其它目录,则需要相应修改struts.xml文件

当编辑链接被点击时,它会打开/edit主题,这将触发一个javascript函数来组装各个域。

  1. 在/WebContent目录下创建一个新文件"index.jsp",它的内容如下:
index.jsp
<% @ taglib prefix = " s "  uri = " /struts-tags " %>
< html >
    
< head >
        
< s:head  theme ="ajax"  debug ="true" />
        
< script  type ="text/javascript" >
            dojo.event.topic.subscribe(
" /save " ,  function (data, type, request) {
                
if (type  ==   " load " ) {
                    dojo.byId(
" id " ).value  =   "" ;
                    dojo.byId(
" firstName " ).value  =   "" ;
                    dojo.byId(
" lastName " ).value  =   "" ;
                }
            });

            dojo.event.topic.subscribe(
" /edit " ,  function (data, type, request) {
                
if (type  ==   " before " ) {
                    
var  id  =  data.split( " _ " )[ 1 ];

                    
var  tr  =  dojo.byId( " row_ " + id);
                    
var  tds  =  tr.getElementsByTagName( " td " );

                    dojo.byId(
" id " ).value  =  id;
                    dojo.byId(
" firstName " ).value  =  dojo.string.trim(dojo.dom.textContent(tds[ 0 ]));
                    dojo.byId(
" lastName " ).value  =  dojo.string.trim(dojo.dom.textContent(tds[ 1 ]));
                }
            });
        
</ script >
    
</ head >
    
< body >
        
< s:url  action ="list"  id ="descrsUrl" />

        
< div  style ="width: 300px;border-style: solid" >
            
< div  style ="text-align: right;" >
                
< s:a  theme ="ajax"  notifyTopics ="/refresh" > Refresh </ s:a >
            
</ div >
            
< s:div  id ="persons"  theme ="ajax"  href ="%{descrsUrl}"  loadingText ="Loading..."  listenTopics ="/refresh" />
        
</ div >

        
< br />

        
< div  style ="width: 300px;border-style: solid" >
            
< p > Person Data </ p >
            
< s:form  action ="save"  validate ="true" >
                
< s:textfield  id ="id"  name ="person.id"  cssStyle ="display:none" />
                
< s:textfield  id ="firstName"  label ="First Name"  name ="person.firstName" />
                
< s:textfield  id ="lastName"  label ="Last Name"  name ="person.lastName" />
                
< s:submit  theme ="ajax"  targets ="persons"  notifyTopics ="/save" />
            
</ s:form >
        
</ div >
    
</ body >
</ html >

看,并没有页面刷新!

"personx" div会异步地装载它的内容,当请求被处理时显示"Loading..."提示(你可以使用"indicator"属性得到更佳的进度反馈),你可以通过点击"Refresh"链接来强制页面进行刷新。"submit"按钮,向action "save"提交一个异步的请求(PersonAction的"save"方法)

 

Validation验证

我们并不想我们的数据库存在任何的无名氏,所以我们给Form增加一点基本的客户端验证。在Struts2中,验证可以被放在xml文件里,命名模式为:ActionName-validation.xml,放在与action相同的包路径下。要给action的特定别名添加验证(比如方法),validation文件的命名必须为:ActionName-alias-validation.xml,这里的"alias"就是你的action的别名(这里也就是方法名,如"save")。在src/quickstart/action目录下添加一个名为"PersonAction-save-validation.xml"文件,它的内容如下:

<! DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//EN"
       "http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd"
>
< validators >
    
< field  name ="person.firstName" >
        
< field-validator  type ="requiredstring" >
            
< message > First name is required! </ message >
        
</ field-validator >
    
</ field >
    
< field  name ="person.lastName" >
        
< field-validator  type ="requiredstring" >
            
< message > Last name is required! </ message >
        
</ field-validator >
    
</ field >
</ validators >

关于现有的validator,以及如何编写和插入你自己的validator,请查看Struts文档

要运行项目,右击你的项目并选择Run AS -> Run on Server。你也可以通过相同的办法来调试它,右击项目 Debug As -> Debug on Server。下载并安装Struts 2的 showcase演示项目来查看更多的例子。

参考资料

Struts
Spring JPA Doc
JPA and Spring Tutorial
Eclipse Dali

 

Trackback: http://tb.blog.youkuaiyun.com/TrackBack.aspx?PostId=1572277

Struts2+hiberante+Spring+Extjs+OA办公系统,完整包 Struts2+hiberante+Spring+Extjs+OA办公系统,完整包正常运行 立即下载

相关推荐

PS2硬盘启动终极指南:从FMCB到OPL,告别光驱打造游戏博物馆

在计算机存储与数据读取领域,硬盘启动技术通过将操作系统或应用程序从本地硬盘直接加载,绕过了传统光驱等外部介质,实现了速度与可靠性的双重提升。其核心原理在于利用引导程序接管系统初始化流程,直接访问硬盘上的特定分区与文件镜像。这项技术的价值在于极大提升了数据读取效率、降低了物理介质损耗,并扩展了存储容量与管理的灵活性。在怀旧游戏硬件改造、嵌入式系统定制等场景中,硬盘启动技术被广泛应用,以实现老旧设备的功能焕新与性能优化。本文聚焦于索尼PS2游戏主机的硬盘启动方案,深入探讨了如何利用FMCB(Free MCBoo

weixin_34295316的博客 1779

java后台开发入门(springboot快速入门)

带领大家借助当下比较流行的springboot框架快速开发属于自己的java后台。即便你是编程小白,没有任何编程基础也可以学习本课程。知识点1,Java2,springboot3,freemarker4,bootstrap4.35,Javaweb6,微信小程序同时会借助当下最热门的微信小程序来作为我们的前端展示。所以课程中也会教给大家一部分小程序开发的知识。大家只需要跟着老师一步步学习,我们既可以学习到java知识,也可以学习到小程序开发和web开发相关的知识。我们学习过程中会有老师在线实时解答,每节课都会有对应的源码和配套笔记给到大家。

属性基加密(Attribute-based Encryption, ABE)

KP-ABE中,用户的密钥定义了访问策略,密文的属性与策略进行匹配。CP-ABE中,密文定义了访问策略,用户的属性与策略进行匹配。

2201_75392924的博客 1832

Java 必看的 Spring 知识汇总

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性的角度而言,绝大部分Java应用都可以从Spring中受益。 Spring优点: 低侵入式设计,代码的污染极低; 独立于各种应用服务器,基于Spring框架的应用,可以真正实现Write Once,Run Anywhere的承诺; Spring的IoC容器降低了业务对象替换的复杂性,提高了组件之间的解耦 S

CRMEB小程序商城的博客 6514

机器学习 -- 信用卡评分模型 -- 互联网金融风控

互联网金融主要分为资金类和资产类。资金类主要是理财产品,吸储,主要指标是用户转化、留存和复投,重在客户运营。资产类主要是贷款,包括消费金融和现金贷,小额贷款属于此类,主要目的是用户转化,还款和风险控制,信用卡评分模型就属于风险控制。 信用评分作用是对贷款申请人(信用卡申请人)做风险评估分值的方法。 信用卡评分是以大量数据的统计结果为基础,根据客户提供的资料和历史数据对客户的信用进行评估,评分卡模型...

XiaoMaEr66的博客 2422

ESP32 Arduino学习篇 (一) 引脚和串口的基本使用

简单来讲arduino就是通过源代码控制开发板的信号输入输出从而实现对一些电子元件的控制,例如LED灯,蜂鸣器,按键arduino程序首先来讲arduino程序是基于C语言,而实现类似对于LED灯和蜂鸣器的简单控制只需简单C语言知识即可实现。arduino程序是基于函数的,而在arduino的库有很多函数,我们只需要调用即可。arduino的程序主体是**setup()函数和loop()**函数以及其它在使用过程中需要构建的函数:setup()函数。

DOF526570的博客 1万+

Java -- Spring

一、Spring简介 1. 概述 Spring是一个轻量级Java开发框架(最早由Rod Johnson创建),为Java应用程序提供全面的基础架构支持。 Spring最根本的使命是解决企业级应用开发的复杂性,简化Java开发。 2. Spring两个核心特性 ① IoC(Inverse of Control)–> 控制反转 IoC理念: 对象的创建工作交给IoC容器 对象间的依赖关系交给IoC容器查找,在运行期间确定 依赖注入是IoC的主要实现方式 IoC的实现机制: 工厂模式 + 反射

DC9751的博客 2916

e-puck场景搭建

可以注意到一个黑色的小窗口出现在三维视图的左上角。它显示了电子吸盘机器人的摄像头拍摄的图像。该图像将保持黑色,直到机器人的控制器明确启用相机。最后,单击右上角的“x”可以关闭它。在对话框中,选择PROTO节点(Webots项目)/robots/gctronic/e-puck/e-puck(Robot)。一个电子吸盘机器人应该出现在竞技场的中央。通过按Alt+左键单击+拖动,对机器人施加力。无法对WoodenBox节点施加力,因为默认情况下,它们没有质量,并且被视为粘在地板上。将新控制器与机器人链接。

weixin_66540163的博客 769

【Spring Boot 教程:从入门到精通】掌握 Spring Boot 开发技巧与窍门(一)-java语法(1)

一些Java基本语法的基本介绍,语法更新结束会紧跟项目实战,后续会持续在该专栏进行更新!!!提示:以下是本篇文章正文内容,下面案例可供参考一些Java基本语法的基本介绍,语法更新结束会紧跟项目实战,后续会持续在该专栏进行更新!!!

m0_63267251的博客 1469

基于YOLOv8和PaddlepaddleOCR的微信截图聊天记录提取

本文提出了一种基于YOLOv8和PaddleOCR的微信聊天记录提取方法。首先使用YOLOv8n模型分割出聊天气泡(针对深浅色模式分别训练),通过合成数据集增强模型鲁棒性,召回率达0.995。随后采用PP-OCRv5进行文本识别,利用坐标匹配将气泡内文本送入识别队列,短长文本平均置信度分别>0.98和>0.95。文中特别强调了PaddleOCR不同版本的输出格式差异及适配方案,建议使用3.0+版本。该方法有效解决了直接OCR识别易受干扰的问题,通过气泡分割+文本定位的两阶段策略显著提升了识别准确

2401_87383958的博客 2358

【网络安全】浅谈数据库攻击复现及相关安全优化

4、准备数据库服务器为了安全正式环境应该把数据库单独放一台服务器,只允许让应用服务器 IP 来访问数据库服务器,通过独立两者,就算其中一台发生问题,另一台也是好的,进一步降低了危险性。5、定时备份数据库开发定时备份功能,可以使用 Crontab,或者其他框架,设定周期备份数据,哪怕是数据丢失或被删除也可以快速恢复。

2401_88545587的博客 223

Eclipse开发: Struts 2 + Spring 2 + JPA + AJAX

本文翻译自:http://cwiki.apache.org/S2WIKI/struts-2-spring-2-jpa-ajax.html来自Struts2 WiKi上的一篇文章,讲解如何在Eclipse + WTP中进行Spring2, Struts2, JPA的整合开发。很基础的说,希望对于想学习SSH的人能有一定的帮助。我在翻译的过程中,也尝试使用MyEclipse来进行整合开发。但由于水

小吹的专栏 2093

YOLOv11与Roboflow数据预处理实战:从原始数据到高性能模型

摘要 Roboflow平台与YOLOv11的结合为计算机视觉开发者提供了高效的工作流。Roboflow提供数据集管理、预处理、增强和导出的一站式解决方案,支持多种标注格式并与YOLOv11无缝集成。YOLOv11在YOLO系列基础上进行了架构创新,包括深度宽度优化、C3k2机制和C2PSA注意力机制,提供从纳米版到超大版的多种模型变体。 使用Roboflow的流程包括:注册工作区、收集/导入数据(支持本地和公开数据集)、专业标注(含SAM辅助)、预处理(尺寸调整、归一化等)和数据增强(几何变换和颜色调整)。

本博客聚焦 YOLOv11 全流程落地,涵盖架构优化、数据集处理、训练技巧与多场景部署,兼及国产数据库、Java 开发与 AI 模型应用,内容兼顾理论与工程实践,为开发者提供系统干货,助力高效提升技术能力。 355

[转]Eclipse开发: Struts 2 + Spring 2 + JPA + AJAX

转自:http://blog.youkuaiyun.com/jk88811/archive/2007/04/20/1572277.aspx 本文翻译自:http://cwiki.apache.org/S2WIKI/struts-2-spring-2-jpa-ajax.html来自Struts2 WiKi上的一篇文章,讲解如何在Eclipse + WTP中进行Spring2, Struts2, JP

剑晖(广州)的专栏 1090

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Struts 2 + Spring 2 + JPA + AJAX

  [本文翻译自:http://struts.apache.org/2.1.6/docs/struts-2-spring-2-jpa-ajax.html]  [翻译:许亮]   来自Apache官方Struts2 WiKi上的一篇文章,讲解如何在Eclipse + WTP中进行Spring2, Struts2, JPA的整合开发。很基础的说,希望对于想学习SSH的人能有一定的帮助。我在

好记性不如烂笔头 973

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

struts2+spring2+hiberante3.2 配置 ,struts2+spring2+JPA+AJAX 配置

本文翻译自:http://cwiki.apache.org/S2WIKI/struts-2-spring-2-jpa-ajax.html我今天下午调试成功的, 昨天调试了一天, 都没有成功, 不是contextLoadListener找不到就是 server start error.  今天调试成功发现原来是人品问题, 是选择hibernate 包的时候没有注意hibernate compat

tgh_china的专栏 3421

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

Spring超硬核笔记———全是干货

eureka主要是通过心跳检测去判断的,有一个发送者和客户端,发送者会每隔30秒发送一个心跳到eureka上去,服务端会把eureka上的客户端发送的数据进行一个接受并调用的过程,如果说生产者没有发送心跳到注册中心上,那么就直接剔除掉,将所有的接口都剔除掉,如果说中途eureka发生了宕机,那么也是可以进行一个调用的,因为将原来的数据放到了一个缓存中 去,并且eureka还有自我保护机制,如果说在15分钟内检测到有85%的服务都宕机了那么这个时候就会认为是一个网络的问题导致的。

2403_86981468的博客 1286

【Java】spring

spring的核心作用就是管理bean。==只需要将实现类注解成bean就可以了接口不用注解成bean。==使用的时候只使用接口。因为spring会根据接口自动获取实现类注入接口。

第三季度的博客 2301

Java经典框架之Spring

即使ServiceB.methodB的事务已经被提交,可是ServiceA.methodA在接下来fail要回滚,ServiceB.methodB也要回滚。再必须强调一遍,不是事务隔离级别设置得越高越好,事务隔离级别设置得越高,意味着势必要花手段去加锁用以保证事务的正确性,那么效率就要降低,因此实际开发中往往要在效率和并发正确性之间做一个取舍,一般情况下会设置为READ_COMMITED,此时避免了脏读,并发性也还不错,之后再通过一些别的手段去解决不可重复读和幻读的问题就好了。这是一个郑重的承诺。

m0_52514893的博客 4384

Java后端框架---Spring

面向切面编程是对面向对象编程的补充延续,面向切面编程思想是将程序中的非业务代码(提交事务,打印日志,权限验证,统一异常处理)在调用业务代码时,通过一个代理对象帮助我们调用这些提取出来的非业务代码,这样在业务代码当中就不用显示的调用非业务代码,这样最终就做到了业务代码和非业务代码的分离,降低了耦合度。面向切面编程的好处:降低了模块之间的耦合度。面向切面编程的原理:采用动态代理模式,给业务代码生成代理对象。本篇博客总结出Java后端框架--Spring的体系结构,指出IOC(控制反转) 和AOP。

2302_78078800的博客 4165

【JAVA】Spring

IOC 容器是具有依赖注入功能的容器,负责对象的实例化、对象的初始化,对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作,对象的整个生命周期都是由容器来控制。事务的作用就是为了保证用户的每一个操作都是可靠的,事务中的每一步操作都必须成功执行,只要有发生异常就回退到事务开始未进行操作的状态,这些操作要么都完成,要么都取消,从而保证数据满足一致性的要求Spring 中的事务管理分为两种形式,一种是编程式事务,一种是声明式事务.AOP 是一种编程思想,是面向对象编程(OOP)的一种补充。

m0_56492261的博客 532

Spring 概述

这里写目录标题1、什么是 Spring ?2、Spring 起源3、Spring 特点4、Spring 框架结构5、Spring 框架特征6、Spring 优点 1、什么是 Spring ? Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层

m0_52384288的博客 770
上一篇: Java中的内部类和匿名类
下一篇: struts2+hibernate+spring配置管理(一)——配置文件
robage
博客等级 码龄22年 4粉丝 7原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值