hibernate annotation 双向 one-to-one 注解
环境：
Hibernate 3.3.1
Maven 3.0.4
MySQL 5.5.13
Myeclipse 8.6.1
建表语句：
DROP TABLE IF EXISTS `t_card`;
CREATE TABLE `t_card` (
`cardId` int(10) unsigned NOT NULL AUTO_INCREMENT,
`cardNumber` char(18) NOT NULL,
PRIMARY KEY (`cardId`)
) ENGINE=InnoDB AUTO_INCREMENT=2DEFAULT CHARSET=gb2312; INSERT INTO `t_card` VALUES ('1', '440911************');
DROP TABLE IF EXISTS `t_person`;
CREATE TABLE `t_person` (
`personId` int(10) unsigned NOT NULL AUTO_INCREMENT,
`personName` varchar(15) NOT NULL,
`cid` int(10) unsigned NOT NULL,
PRIMARY KEY (`personId`)
) ENGINE=InnoDB AUTO_INCREMENT=2DEFAULT CHARSET=gb2312; INSERT INTO `t_person` VALUES ('1', 'fancy', '1');
Person.java
package com.fancy.po;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
/**
* -----------------------------------------
* @文件: Person.java
* @作者: fancy
* @邮箱: fancyzero@https://www.wendangku.net/doc/ba10878063.html,
* @时间: 2012-6-10
* @描述: 实体类
* -----------------------------------------
*/
/**
* @Entity 声明一个类为实体Bean
* @Table(name = "xx")指定实体类映射的表,如果表名和实体类名一致,可以不指定
*/
@Entity
@Table(name = "t_person")
public class Person {
private Integer personId;
private String personName;
private Card card;
/**
* @Id 映射主键属性,这里采用uuid的主键生成策略
* @GeneratedValue ——注解声明了主键的生成策略。该注解有如下属性
* strategy 指定生成的策略,默认是GenerationType. AUTO
* GenerationType.AUTO 主键由程序控制
* GenerationType.TABLE 使用一个特定的数据库表格来保存主键
* GenerationType.IDENTITY 主键由数据库自动生成,主要是自动增长类型
* GenerationType.SEQUENCE 根据底层数据库的序列来生成主键，条件是数据库支持序列 * generator 指定生成主键使用的生成器
*/
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
public Integer getPersonId() {
return personId;
}
/**
* @OneToOne：一对一关联
* cascade：级联,它可以有有五个值可选,分别是：
* CascadeType.PERSIST：级联新建
* CascadeType.REMOVE : 级联删除
* CascadeType.REFRESH：级联刷新
* CascadeType.MERGE ：级联更新
* CascadeType.ALL ：以上全部四项
* @JoinColumn:主表外键字段
* cid：Person所映射的表中的一个字段
*/
@OneToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "cid")
public Card getCard() {
return card;
}
public String getPersonName() {
return personName;
}
public void setPersonId(Integer personId) { this.personId = personId;
}
public void setPersonName(String personName) { this.personName = personName;
}
public void setCard(Card card) {
this.card = card;
}
}
Card.java
package com.fancy.po;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
/**
* -----------------------------------------
* @文件: Card.java
* @作者: fancy
* @邮箱: fancyzero@https://www.wendangku.net/doc/ba10878063.html,
* @时间: 2012-6-10
* @描述: 实体类
* -----------------------------------------
*/
@Entity
@Table(name = "t_card")
public class Card {
private Integer cardId;
private String cardNumber;
private Person person;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
public Integer getCardId() {
return cardId;
}
/**
* @OneToOne：一对一关联
* mappedBy = "card"：意思是说这里的一对一配置参考了card
* card又是什么呢?card是Person类中的getCard(),注意不是Person类中的 * card属性,Person类中的OneToOne配置就是在getCard()方法上面配的. * 如果Person类中的getCard()方法改成getIdCard(),其他不变的话,
* 这里就要写成：mappedBy = "idCard"
*/
@OneToOne(mappedBy = "card")
public Person getPerson() {
return person;
}
public String getCardNumber() {
return cardNumber;
}
public void setCardId(Integer cardId) {
this.cardId = cardId;
}
public void setCardNumber(String cardNumber) {
this.cardNumber = cardNumber;
}
public void setPerson(Person person) {
this.person = person;
}
}
pom.xml
xmlns:xsi="https://www.wendangku.net/doc/ba10878063.html,/2001/XMLSchema-instance" xsi:schemaLocation="https://www.wendangku.net/doc/ba10878063.html,/POM/4.0.0 https://www.wendangku.net/doc/ba10878063.html,/xsd/maven-4.0.0.xsd">
在生成数据库表的过程中，
报 javax.persistence.OneToMany.orphanRemoval()Z异常的解决方法：去掉myeclipse中的j2ee包居然就可以了！！
@oneToMany(mappedBy="另一方类中对应的属性名（外键）
",cascade=CascadeType.ALL,fetch=FetchType.EAGER)就相当于xml配置中的
inverse=true
在单向关系中没有mappedBy。
mappedBy一定是定义在the owned side(被拥有方的)，他指向the owning side(拥有方)；主控方相当于拥有指向另一方的外键的一方。
mappedBy指定的是不需要维护关系的一端
@ManyToOne
@JoinColumn(name="外键的字段名")
1.一对一和多对一的@JoinColumn注解的都是在“主控方”，都是本表指向外表的外键名称。
2.一对多的@JoinColumn注解在“被控方”，即一的一方，指的是外表中指向本表的外键名称。
3.多对多中，joinColumns写的都是本表在中间表的外键名称，
inverseJoinColumns写的是另一个表在中间表的外键名称。
mappedBy跟JoinColumn/JoinTable总是处于互斥的一方
如产品类型和产品的关系：
@Entity
@Table(name="tb_productType")//经常给漏掉这东西
public class ProductType extends BaseBean
{
private static final long serialVersionUID = 3466104768256418884L;
@Column(nullable=false,unique=true)
private String name;
@OneToMany(mappedBy="type",cascade=CascadeType.ALL,fetch=FetchType.EAGER) private List
...
和：
@Entity
@Table(name="tb_product")
public class Product extends BaseBean
{
private static final long serialVersionUID = 4109238647414563541L; @Column(nullable=false)
private String name;
@Column(precision=2)
private double price;
@Basic(fetch = https://www.wendangku.net/doc/ba10878063.html,ZY)
@Column(columnDefinition = "longtext")
private String intro;
private String masterDrowing;
@ManyToOne
@JoinColumn(name="productType_id")
private ProductType type;
private String comment;
private int hit;
private boolean finalRealse;
private int count;
@ManyToOne
@JoinColumn(name="person_id")
private Person contacter;
@Temporal(value = TemporalType.DATE)
private Date realseDate;
...
hibernate的配置文件：
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/site?characterEncoding=UTF-8
org.hibernate.dialect.MySQLDialect
产生数据库表的类：
createTable类
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
public class CreateTable {
static void create(){
SchemaExport export = new SchemaExport(new AnnotationConfiguration().configure());
export.create(true, true);
}
public static void main(String[] args){
create();
}
}
经过这些配置就可以生成数据库表了！！
单向关系中的JoinColumn
1.person与address的一对一单向关系：
在address中没有特殊的注解。
在Person中对应到数据库里面就有一个指向Address的外键.
我们也可以增加注释指定外键的列的名字,如下:
@OneToOne(cascade=CascadeType.ALL,optional=true)
@JoinColumn(name="addressID")//注释本表中指向另一个表的外键。
public Address getAddress() {
return address;
}
如果我们不加的话,也是可以通过的,在JBOSS里面,它会自动帮你生成你指向这个类的类名加上下划线再加上id的列,也就是默认列名是:address_id.
如果是主键相关联的话,那么可以运用如下注释
@OneToOne(cascade={CascadeType.ALL})
@PrimaryKeyJoinColumn
public Address getAddress( ) {
return hom eAddress;
}
它表示两张表的关联是根据两张表的主键的
—————————————————————————————————————————————————————————————————————
2.person和phone的一对多单向关系：
phone中没有特别的注释。
person中：
@OneToMany(cascade=CascadeType.ALL)
@JoinColumn(name="personID")//注释的是另一个表指向本表的外键。
public List
return phones;
}
我们可以在Person类里面发现@JoinColumn(name="personID")
它代表是一对多,一是指类本身,多是指这个成员,也就是一个类可以对应多个成员.
在一对多里面,无论是单向还是双向,映射关系的维护端都是在多的那一方,也就是Phone那里,因为要在数据库面表现的话,也只有让Phone起一个指向Person的外键,不可能在Person里面指向Phone,这一点和一对一不一样,一对一可以在任意一方起一个外键指向对方.可是一对多却不行了.
在这里@JoinColumn这个注释指的却是在Phone里面的外键的列的名字,
它并不像在一对一里面的注释指的是自己表里面的外键列名.这一点要特别注意一下.
如果是一对多的双向关系,那么这个注释就要应用到多的那边去了,虽然注释还在Person类里面,但是它起的效果却是在Phone里面起一个叫personID的外键, 因为多的那边要有外键指向少的这边.
如果你不加@JoinColumn(name="personID")这个注释的话,那么JBOSS就会自动帮你生成一张中间表,
它负现Person和Phone表之间的联系.它将会做如下事情:
CREATE TABLE PERSON_PHONE
(
PERSON_id INT,
PHONE_id INT
);
ALTER TABLE PERSON_PHONE ADD CONSTRAINT person_phone_unique UNIQUE (PHONE_id);
ALTER TABLE PERSON_PHONE ADD CONSTRAINT personREFphone
FOREIGN KEY (PERSON_id) REFERENCES PERSON (id);
ALTER TABLE PERSON_PHONE ADD CONSTRAINT personREFphone2 FOREIGN KEY (PHONE_id) REFERENCES PHONE (id);
所以我们最好还是指定一下,以让程序产生更加确定的行为，不过一般是推荐另外生成一个中间表好一些，因为这样的话，对原来两张表的结构不对造成任何影响。在遗留系统的时候很多用，有些时候，一些表都是以前就建好了的，要改表的结构是不太可能的，所以这个时候中间的表就显得很重要了，它可以在不侵入原来表的情况下构建出一种更清淅更易管理的关系。
所以一对多的单向关联，我们还是推荐使用一张中间表来建立关系。
---------------------------------------------------------------------------------------------------------------------------------------------
3.person和country的多对一单向关系：
country中无特别的注解。
而person注解如下：
@ManyToOne
@JoinColumn(name="countryID")
public Country getCountry() {
return country;
}
在一对多一对多一对的关系里面，关系的维护端都是在多的那一面，多的一面为主控方，拥有指向对方的外键。
因为主控端是Person .外键也是建在Person上面，因为它是多的一面。当然我们在这里也可以省掉@JoinColumn，那样的话会怎么样呢，会不会像一对多单向一样生成中间的表呢？事实是不会的，在这里如果我们去掉@JoinColumn的话，那么一样会在Person表里面生成一列指向
Country的外键，这一点和一对多的单向是不一样，在一对多的单向里面，如果我们不在Person 里面加上@JoinColumn这个注释，那么JBOSS将会为我们生成一个中间的表，这个表会有一个列指向Person主键，一个列指向Phone主键。所以说为了程序有一定的行为，有些东西我们还是不要省的好。
其实多对一单向是有点向一对一单向的，在主控端里面，也就是从Person的角度来看，也就是对应了一个Country而已，只不过这个Country是很多Person所共用的，而一对一却没有这一点限制。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
4.person和project的多对多单向关系：
project没有特殊的注解。
person：
@ManyToMany
public List
return projects;
}
它需要设置中间表来维护关系，在数据库上跟多对多双向，只不过在编程的逻辑中不一样而已。
//类似这个：@JoinTable(name = "PersonANDFlight", joinColumns =
{@JoinColumn(name = "personID")},
//inverseJoinColumns = {@JoinColumn(name = "flightID")})
其实这个声明不是必要的,当我们不用@JoinTable来声明的时候,JBOSS也会为我们自动生成一个连接用的表,
表名默认是主控端的表名加上下划线"_"再加上反转端的表名.
类似
@ManyToMany(cascade = CascadeType.ALL)
@JoinTable(name = "PersonANDFlight",
joinColumns = {@JoinColumn(name = "personID")},
inverseJoinColumns = {@JoinColumn(name = "flightID")}) public List
return flights;
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
在单向关系中没有mappedBy,主控方相当于拥有指向另一方的外键的一方。
1.一对一和多对一的@JoinColumn注解的都是在“主控方”，都是本表指向外表的外键名称。
2.一对多的@JoinColumn注解在“被控方”，即一的一方，指的是外表中指向本表的外键名称。
3.多对多中，joinColumns写的都是本表在中间表的外键名称，
inverseJoinColumns写的是另一个表在中间表的外键名称。
使用@OneToOne注解可以建立实体bean之间的一对一的关联。
一对一关联有两种情况：
一是关联的实体都共享同样的主键，
二是其中一个实体通过外键关联到另一个实体的主键
（注意要模拟一对一关联必须在外键字段上添加唯一性约束）.
First, we map a real one-to-one association using shared primary keys:
首先，我们通过共享主键来进行一对一关联映射:
@Entity
public class Body {
@Id
public Long getId() { return id; }
@OneToOne(cascade = CascadeType.ALL)
@PrimaryKeyJoinColumn
public Heart getHeart() {
return heart;
}
...
}
@Entity
public class Heart {
@Id
public Long getId() { ...}
}
The one to one is marked as true by using the
@PrimaryKeyJoinColumn annotation.
通过使用@PrimaryKeyJoinColumn注解定义了一对一关联。
In the following example, the associated entities are linked through a foreign key column:
下面这个例子使用外键进行实体的关联。
@Entity
public class Customer implements Serializable {
@OneToOne(cascade = CascadeType.ALL)
@JoinColumn(name="passport_fk")
public Passport getPassport() {
...
}
@Entity
public class Passport implements Serializable {
@OneToOne( mappedBy = "passport" )
public Customer getOwner() {
...
}
A Customer is linked to a
Passport , with a foreign key column nam ed
??passport_fk in the Customer ??
table. The join column is declared with the
@JoinColumn annotation which looks like the
@Column annotation. It has one more parameters
named referencedColumnName . This parameter declares
the column in the targeted entity that will be used to the join. Note that when using
???? referencedColumnName ?? to a non??
primary key column, the associated class has to be
Serializable . Also note that the
???? referencedColumnName ?? to a non??
primary key column has to be mapped to a property having a single column (other cases might not work).
上面这个例子中，Customer通过Customer
表中名为的passport_fk外键和Passport关联。
@JoinColumn注解定义了关联字段。
该注解和@Column注解有点类似，
但是多了一个名为referencedColumnName的参数。
该参数定义了所关联目标实体中的关联字段。
注意，当?? ??referencedColumnName ?? 关联到非主键字段的时候，?? 关联的目标类必须实现Serializable，
还要注意的是所映射的属性只有单个字段(否则映射无效)。
.
The association may be bidirectional. In a bidirectional relationship, one of the sides (and only one) has to be the owner: the owner is responsible for the association column(s) update. To declare a side as not responsible for the relationship,
the attribute mappedBy is used.
mappedBy refers to the property name of the
association on the owner side. In our case, this is
passport . As you can see, you don't have to (must
not) declare the join column since it has already been declared on the owners side.
一对一关联可能是双向的。在双向关联中，
有且仅有一端是作为owner存在的：owner负责维护关联字段（即更新）。
对于不需要维护这种关系的一端则通过mappedBy属性进行声明。
mappedBy的值指向owner端的关联属性。
在上面这个例子中，??mappedBy的值为passport。??
最后，不必也不能再在另外一端（非owner端）定义关联字段了，
因为已经在owner端进行了声明。
If no @JoinColumn is declared on the owner
side, the defaults apply. A join column(s) will be created in the
owner table and its name will be the concatenation of the name of the relationship in the owner side,
passport and the column id of Passport
???? is id .
如果在owner端没有声明@JoinColumn，系统自动进行处理：
在owner表中将创建关联字段，
字段名为：owner端的关联属性名＋下划线＋被关联端的主键字段名。
在上面这个例子中是passport_id，
因为??Customer中关联属性名为passport，??
??Passport的主键是id。??
Many-to-one
Many-to-one associations are declared at the property level with
the annotation @ManyToOne :
在实体属性一级使用@ManyToOne注解来定义多对一关联:
@Entity()
public class Flight implements Serializable {
@ManyToOne ( cascade = {CascadeType.CREATE, CascadeType.MERGE} ) @JoinColumn(name="COMP_ID")
public Company getCompany() {
return company;
}
...
}
The @JoinColumn attribute is optional, the
default value(s) is like in one to one, the concatenation of the name
of the relationship in the owner side,
(underscore), and the nam e of the primary key column in the owned
side. In this example company_id because the
property name is company and the column id of
Company is id .
其中@JoinColumn是可选的，关联字段默认值和一对一
（one to one）关联的情况相似，
也是"owner端的关联属性名＋下划线＋被关联端的主键字段名"。
在这个例子中是company_id，
因为关联的属性是company，
??Company的主键是id。??
@ManyToOne has a param eter nam ed
targetEntity which describes the target entity
name. You usually don't need this param eter since the default value
(the type of the property that stores the association) is good in
almost all cases. However this is useful when you want to use
interfaces as the return type instead of the regular entity.
??@ManyToOne注解有一个名为targetEntity的参数，??
该参数定义了目标实体名。通常不需要定义该参数，
因为在大部分情况下默认值（表示关联关系的属性类型）就可以很好的满足要求了。
不过下面这种情况下这个参数就显得有意义了：使用接口作为返回值而不是常见的实体。
@Entity()
public class Flight implements Serializable {
@ManyT oOne( cascade = {CascadeType.CREATE, CascadeType.MERGE}, targetEntity=CompanyImpl.class )
@JoinColumn(name="COMP_ID")
public Company getCompany() {
return company;
}
...
}
public interface Company {
...
Collections
Overview
You can map Collection ,
List (ie ordered lists, not indexed lists),
Map and Set . The EJB3
specification describes how to map an ordered list (ie a list
ordered at load time) using
@javax.persistence.OrderBy annotation: this
annotation takes into parameter a list of comma separated (target
entity) properties to order the collection by (eg firstname
asc, age desc), if the string is empty, the collection will
be ordered by id. @OrderBy currently works only
on collections having no association table. For true indexed
collections, please refer to the
EJB3 allows you to map Maps using as a key one of the target entity
property using @MapKey(name="myProperty")
(myProperty is a property name in the target entity). When using
@MapKey (without property name), the target
entity primary key is used. Be aware that once loaded, the key is no
longer kept in sync with the property, in other words, if you change
the property value, the key will not change automatically in your
Java model (Map support the way Hibernate 3 does is currently not
supported in this release).
你可以对*Collection * ，List
（指有序list, 而不是索引式list），
Map和Set这几种类型进行映射。
EJB3规范定义了怎么样使用@javax.persistence.OrderBy
注解来对有序list进行映射：
该注解接受的参数格式：用逗号隔开的（目标实体）属性名及排序指令，
如firstname asc, age desc，如果该参数为空，则默认以id对该集合进行排序。对于true indexed collections，请参考
EJB3允许使用@MapKey(name="myProperty")
来把Map映射为目标实体的属性（myProperty是目标实体的一个属性）。
如果使用@MapKey注解的时候不提供属性名，
系统默认使用目标实体的主键。
注意一旦加载，key不再和属性保持同步，
也就是说，如果你改变了该属性的值，在你的java模型中的key不会自动更新。
(Hibernate 3中Map支持的方式在当前的发布版中还未得到支持).
Hibernate has several notions of collections.
Hibernate将集合分以下几类.
@org.hibernate.annotations.IndexColumn are going to be considered as
bags.
@org.hibernate.annotations.IndexColumn 注解的java.util.List集合将不被看作bag类.
Collection of primitive, core type or embedded objects is not
supported by the EJB3 specification. Hibernate Annotations allows
them however (see
EJB3规范不支持原始类型，核心类型，嵌入式对象的集合。但是Hibernate对此提供了支持(详情参考
@Entity public class City {
@OneToMany(mappedBy="city")
@OrderBy("streetName")
public List
return streets;
}
...
}
@Entity public class Street {
public String getStreetName() {
return streetName;
}
@ManyT oOne
public City getCity() {
return city;
}
...
}
@Entity
public class Software {
@OneToMany(mappedBy="software")
@MapKey(name="codeName")
public Map
return versions;
}
...
}
@Entity
@Table(name="tbl_version")
public class Version {
public String getCodeName() {...}
@ManyT oOne
public Software getSoftware() { ... }
...
}
So City has a collection of
Street s that are ordered by
??streetName (of Street ) when??
the collection is loaded. Software has a map of
Version s which key is the
??Version codeName .??
上面这个例子中，City
中包括了以??streetName排序的Street的集合。?? 而??Software中包括了以codeName作为??
key和以Version作为值的Map。
Unless the collection is a generic, you will have to define targetEntity . This is a annotation attribute that
take the target entity class as a value.
除非集合为generic类型，否则你需要指定targetEntity。
这个注解属性接受的参数为目标实体的class。
One-to-many
annotation入门_
Java Annotation 入门
摘要： 本文针对 java 初学者或者 annotation 初次使用者全面地说明了 annotation 的使用方法、定义 方式、分类。初学者可以通过以上的说明制作简单的 annotation 程序，但是对于一些高级的 an notation 应用（例如使用自定义 annotation 生成 javabean 映射 xml 文件）还需要进一步的研 究和探讨。涉及到深入 annotation 的内容，作者将在后文《Java Annotation 高级应用》中谈 到。
同时，annotation 运行存在两种方式：运行时、编译时。上文中讨论的都是在运行时的 annota tion 应用，但在编译时的 annotation 应用还没有涉及，
一、为什么使用 Annotation：
在 JAVA 应用中，我们常遇到一些需要使用模版代码。例如，为了编写一个 JAX-RPC web serv ice，我们必须提供一对接口和实现作为模版代码。如果使用 annotation 对远程访问的方法代码 进行修饰的话，这个模版就能够使用工具自动生成。 另外，一些 API 需要使用与程序代码同时维护的附属文件。例如，JavaBeans 需要一个 BeanIn fo Class 与一个 Bean 同时使用/维护，而 EJB 则同样需要一个部署描述符。此时在程序中使用 a nnotation 来维护这些附属文件的信息将十分便利而且减少了错误。
二、Annotation 工作方式：
在 5.0 版之前的 Java 平台已经具有了一些 ad hoc annotation 机制。比如，使用 transient 修 饰符来标识一个成员变量在序列化子系统中应被忽略。而@deprecated 这个 javadoc tag 也是 一个 ad hoc annotation 用来说明一个方法已过时。从 Java5.0 版发布以来，5.0 平台提供了 一个正式的 annotation 功能：允许开发者定义、使用自己的 annoatation 类型。此功能由一个 定义 annotation 类型的语法和一个描述 annotation 声明的语法，读取 annotaion 的 API，一 个使用 annotation 修饰的 class 文件，一个 annotation 处理工具（apt）组成。
1
shiro入门教程
一、介绍： shiro是apache提供的强大而灵活的开源安全框架，它主要用来处理身份认证，授权，企业会话管理和加密。 shiro功能：用户验证、用户执行访问权限控制、在任何环境下使用session API，如cs程序。可以使用多数据源如同时使用oracle、mysql。单点登录(sso)支持。remember me服务。详细介绍还请看官网的使用手册：https://www.wendangku.net/doc/ba10878063.html,/reference.html 与spring security区别，个人觉得二者的主要区别是： 1、shiro灵活性强，易学易扩展。同时，不仅可以在web中使用，可以工作在任务环境内中。 2、acegi灵活性较差，比较难懂，同时与spring整合性好。 如果对权限要求比较高的项目，个人建议使用shiro，主要原因是可以很容易按业务需求进行扩展。 附件是对与shiro集成的jar整合及源码。 二、shiro与spring集成 shiro默认的配置，主要是加载ini文件进行初始化工作，具体配置，还请看官网的使用手册（https://www.wendangku.net/doc/ba10878063.html,/web.html）init文件不支持与spring的集成。此处主要是如何与spring及springmvc集成。 1、web.xml中配置shiro过滤器，web.xml中的配置类使用了spring的过滤代理类来完成。 Xml代码 2、在spring中的application.xml文件中添加shiro配置：
Java代码
anon org.apache.shiro.web.filter.authc.AnonymousFilter authc org.apache.shiro.web.filter.authc.FormAuthenticatio nFilter authcBasic org.apache.shiro.web.filter.authc.BasicHttpAuthenti cationFilter logout org.apache.shiro.web.filter.authc.LogoutFilter noSessionCrea tion org.apache.shiro.web.filter.session.NoSessionCreati onFilter perms org.apache.shiro.web.filter.authz.PermissionsAuthor izationFilter port org.apache.shiro.web.filter.authz.PortFilter rest org.apache.shiro.web.filter.authz.HttpMethodPermiss ionFilter roles org.apache.shiro.web.filter.authz.RolesAuthorizatio nFilter ssl org.apache.shiro.web.filter.authz.SslFilter user https://www.wendangku.net/doc/ba10878063.html,erFilter
hibernate和spring框架技术难点及其要点总结
个人总结希望能给你带来一些帮助,限于时间篇幅只能如此,如有不方便之处,望见谅. 出处个人博客: https://www.wendangku.net/doc/ba10878063.html,/blog hibernate二级缓存 二级缓存也称为进程级的缓存或SessionFactory级的缓存，二级缓存可以被所有的session共享阅读全文>> 标签：缓存hibernate hibernate配置 2012-6-20 15:50:00 点击：19 评论：0 hibernate与jdbc应用对比 一、Hibernate是JDBC的轻量级的对象封装，它是一个独立的对象持久层框架，和App Server，和EJB没有什么必然的联系。Hibernate可以用在任何JDBC可以使用的场合，例如Java应用程序的数据库访问代码，DAO接口的实现类，甚至可以是BMP里面的访问数据库的... 阅读全文>> 标签：hibernate jdbc 2012-5-21 13:57:00 点击：0 评论：0 HibernateDaoSupport与JdbcDaoSupport Dao 的支持类可以有好多，如： JdbcDaoSupport ， HibernateDaoSupport ，JdoDaoSupport等，下面对最常用的HibernateDaoSupport与JdbcDaoSupport做一小总结：一、在Spring框架中实现连接数... 阅读全文>> 2012-5-21 13:53:00 点击：1 评论：0 Hibernate的几种查询方式-HQL,QBC,QBE,离线查询,复合查询,分页查询... HQL查询方式这一种我最常用，也是最喜欢用的，因为它写起来灵活直观，而且与所熟悉的SQL的语法差不太多。条件查询、分页查询、连接查询、嵌套查询，写起来与SQL语法基本一致，唯一不同的就是把表名换成了类或者对象。其它的，包括一些查询函数（count(),sum()等）、... 阅读全文>> 标签：hibernate 2012-5-21 13:51:00 点击：1 评论：0 hibernate的createSQLQuery的几种用法 用法一：对原生SQL查询执行的控制是通过SQLQuery接口进行的，通过执行 Session.createSQLQuery()获取这个接口。最简单的情况下，我们可以采用以下形式：List cats = sess.c... 阅读全文>> 2012-5-21 13:44:00 点击：0 评论：0 HQL:hibernate查询返回各类型结果数据 1. 查询整个映射对象所有字段Java代码 //直接from查询出来的是一个映射对象，即：查询整个映射对象所有字段 &nbs... 阅读全文>> 2012-5-21 13:38:00 点击：1 评论：0 HQL:Hibernate查询语言 在where子句中允许使用的表达式包括大多数你可以在SQL使用的表达式种类:数学运算符+, -, *, /二进制比较运算符=, >=, <=, <>, !=, like逻辑运算符and, or, notin, not in, between, is nu... 阅读全文>> 2012-5-21 13:34:00 点击：0 评论：0 Hibernate 参数设置一览表 属性名用途hibernate.dialect一个Hibernate Dialect类名允许Hibernate针对特定的关系数据库生成优化的SQL. 取值 full.classname.of.Dialect hibernate.show_sql输出所有SQL语句到控制台. 有一... 阅读全文>>
RESTEasy入门经典
RESTEasy是JBoss的开源项目之一，是一个RESTful Web Services框架。RESTEasy的开发者Bill Burke同时也是JAX-RS的J2EE标准制定者之一。JAX-RS 是一个JCP制订的新标准，用于规范基于HTTP的RESTful Web Services的API。 我们已经有SOAP了，为什么需要Restful WebServices？用Bill自己的话来说："如果是为了构建SOA应用，从技术选型的角度来讲，我相信REST比SOAP更具优势。开发人员会意识到使用传统方式有进行SOA架构有多复杂，更不用提使用这些做出来的接口了。这时他们就会发现Restful Web Services的光明之处。" 说了这么多，我们使用RESTEasy做一个项目玩玩看。首先创造一个maven1的web 项目 Java代码 1.mvn archetype:create -DgroupId=org.bluedash \ 2. 3.-DartifactId=try-resteasy -DarchetypeArtifactId=maven-archetype -webapp 准备工作完成后，我们就可以开始写代码了，假设我们要撰写一个处理客户信息的Web Service，它包含两个功能：一是添加用户信息；二是通过用户Id，获取某个用户的信息，而交互的方式是标准的WebService形式，数据交换格式为XML。假设一条用户包含两个属性：Id和用户名。那么我们设计交换的XML数据如下: Java代码 1.
Hibernate常见概念以及关键技术
软件开发的分层思想： 三层架构： 数据表现层业务逻辑层数据持久层 SUN的桌面应用Swing AWT 普通Java类JDBC SUN的WEB基本应用JSP 普通Servlet JDBC SUN的WEB高级应用JSF SessionBean Persistence WEB国内流行开源Struts Spring Hibernate 一、对象持久化的理论 1.对象持久化：内存中的对象转存到外部持久设备上，在需要的时候还可以恢复。 2.对象持久化的原因(目标)：// 是基础工作！是信息共享的主要原因 物理：1) 内存不能持久，需要在硬盘上持久保存//(物理上，物理的都不是根本原因) 2) 内存容量有限，需要在容量更大的硬盘上保存 应用：3) 共享(Internet的本质：信息的收集、整理、发布) //最重要的原因 4) 检索(大规模) //也很重要 5) 管理(备份、安全) 3.怎样进行对象持久化？(仅从JA V A方面讲) 物理：1) 对象序列化 2) DB技术(JDBC 数据库) 4.怎样利用数据库做对象持久化？ 优点：功能完备、理论上效率高 缺点：复杂(难)、代码量大、面向R(过程；二维表关系) 2) EJB 仅讲Entity Bean 优点：封装JDBC 缺点：更复杂的API、重量级(侵入式)、功能不完备、难共享 缺点的后果：开发周期长、测试困难、面向过程 以上是2.0之前的版本，但3.0跟Hibernate基本一样 3) ORM 轻量级框架(Hibernate) 现阶段最佳的持久化工具：文档齐全、服务很好、工业标准、大量应用、易学 优点：封装JBDC、简单的API、轻量级(只做持久化)(用类库)、PO(持久对象)->POJO(纯JA V A)、开源 缺点：不够JDBC灵活 5.结论： 1)对象持久化是必须的 2)必须使用DB来实现 3)Hibernate必须的(现阶段最佳选择) 开源工具的通常问题：1.文档不全；2.服务不全；3.标准化不够 而Hibernate避免了所有这些问题 二、ORM和Hibernate的相关知识(理解)
ERDAS IMAGINE快速入门
实验一ERDAS IMAGINE快速入门 一、背景知识 ERDAS IMAGINE是美国ERDAS公司开发的遥感图像处理系统，后来被Leica公司合并。它以其先进的图像处理技术，友好、灵活的用户界面和操作方式，面向广阔应用领域的产品模块，服务于不同层次用户的模型开发工具以及高度的RS/GIS（遥感图像处理和地理信息系统）集成功能，为遥感及相关应用领域的用户提供了内容丰富而功能强大的图像处理工具，代表了遥感图像处理系统未来的发展趋势。 ERDAS IMAGINE是以模块化的方式提供给用户的，可使用户根据自己的应用要求、资金情况合理地选择不同功能模块及其不同组合，对系统进行剪裁，充分利用软硬件资源，并最大限度地满足用户的专业应用要求，目前的最高版本为9.1。ERDAS IMAGINE面向不同需求的用户，对于系统的扩展功能采用开放的体系结构以IMAGINE Essentials、IMAGINE Advantage、IMAGINE Professional的形式为用户提供了低、中、高三档产品架构，并有丰富的功能扩展模块供用户选择，使产品模块的组合具有极大的灵活性。 ?IMAGINE Essentials级：是一个花费极少的，包括有制图和可视化核心功能的影像工具软件。该级功能的重点在于遥感图像的输入、输出与显示；图像库的 建立与查询管理；专题制图；简单几何纠正与非监督分类等。 ?IMAGINE Advantage级：是建立在IMAGINE Essential级基础之上的，增加了更丰富的图像光栅GIS和单片航片正射校正等强大功能的软件。IMAGINE Advantag提供了灵活可靠的用于光栅分析，正射校正，地形编辑及先进的影像 镶嵌工具。简而言之，IMAGINE Advantage是一个完整的图像地理信息系统 （Imaging GIS）。 ?IMAGINE Professional级：是面向从事复杂分析，需要最新和最全面处理工具，
利用轻量对象关系映射技术Hibernate提高开发效率
利用轻量对象关系映射技术Hibernate提高开发效率 Enhancing Development Efficiency with Hibernate a Lightweight Object/Relational Mapping Technology 谢挺 周维民 （上海大学机电工程与自动化学院，上海 200072） 摘 要 Hibernate是一种轻量对象关系映射技术。文章通过实例，介绍了Hibernate的一些关键特性，并阐述了该技术的一些局限性。 关键词 Hibernate 对象关系映射企业级JavaBeans 持久化 Abstract Hibernate is a lightweight Object/Relational Mapping(ORM) technology. Some key features of Hibernate are illustrated, and some limits of this technology are expounded. Keywords Hibernate Object/Relational Mapping (ORM) EJB Permanence 0 引言 随着internet的发展，应用服务程序已经从集中式、C/S模式过渡到B/S、分布式模式；无论是用户或是供应商都迫切希望缩短开发周期、提高开发效率，Hibernate应运而生。 1 Hibernate简介 Hibernate是一个面向Java环境的对象/关系数据库映射工具。对象/关系数据库映射(Object/Relational Mapping , ORM)这个术语表示一种技术，用来把对象模型表示的对象映射到基于SQL的关系模型中去。 Hibernate不仅提高Java类到数据库的映射，还提供数据查询和获取数据的方法。Hibernate在英语中的意思是“冬眠”，顾名思义它使得商务逻辑的开发和数据库最大程度地分离，可以大幅度减少开发时人工使用SQL和JDBC处理数据的时间。Hibernate的目标是解放开发者通常与数据持久化相关的编程任务的95％。对于那些在基于Java的中间层应用中，它们实现面向对象的业务模型和商业逻辑的应用，Hibernate是很有用的。 图1是Hibernate的体系结构图，从图中可以Array看到，系统为3层B/S模式，应用程序在客户端运 行将持久化的对象交由Hibernate。Hibernate通过 properties属性设置和XML Mapping实现商务逻 辑，调用和存储低层数据库后将返回的结果送给 客户端。 Hibernate对每一种数据库都有对应的 Dialect进行操作优化,从而提高它在各种情况 下的效率。目前,它的版本为3.0、支持的数据 库有Oracle、DB2、MySQL、PostgreSQL、Sybase,Interbase、Pointbase、Microsoft SQL Server、
二次开发入门MapBasic--MapInfo教程
MapInfo教程--二次开发入门摘要：MapBasic是Mapinfo自带的二次开发语言，它是一种类似Basic的解释性语言，利用MapBasic编程生成的*.mbx文件能在Mapinfo软件平台上运行，早期的Mapinfo二次开发都是基于MapBasic进行的。MapBasic学起来容易，用起来却束缚多多，无法实现较复杂的自定义功能，用它来建立用户界面也很麻烦，从现在角度看，MapBasic比较适合用于扩展Mapinfo功能。 一、利用MapBasic开发 MapBasic是Mapinfo自带的二次开发语言，它是一种类似Basic的解释性语言，利用MapBasic编程生成的*.mbx文件能在Mapinfo软件平台上运行，早期的Mapinfo二次开发都是基于MapBasic进行的。MapBasic学起来容易，用起来却束缚多多，无法实现较复杂的自定义功能，用它来建立用户界面也很麻烦，从现在角度看，MapBasic比较适合用于扩展Mapinfo功能。 二、利用OLE自动化开发 1. 建立Mapinfo自动化对象 基于OLE自动化的开发就是编程人员通过标准化编程工具如VC、VB、Delphi、PB等建立自动化控制器，然后通过传送类似MapBasic语言的宏命令对Mapinfo进行操作。实际上是将Mapinfo用作进程外服务器，它在后台输出OLE自动化对象，供控制器调用它的属性和方法。 OLE自动化开发的首要一步就是建立Mapinfo自动化对象，以Delphi为例(后面都是如此)，你可设定一个Variant类型的全程变量代表OLE自动化对象，假设该变量名为olemapinfo，那么有： oleMapinfo := CreateOleObject('Mapinfo.Application') 一旦OLE自动化对象建立，也就是后台Mapinfo成功启动，你就可以使用该对象的Do方法向Mapinfo发送命令，如： oleMapinfo.Do('Set Next Document Parent' + WinHand + 'Style 1') 这一命令使Mapinfo窗口成为应用程序的子窗口，WinHand是地图窗口句柄，style 1 是没有边框的窗口类型。你还可以使用自动化对象的Eval方法返回MapBasic表达式的值，如下面语句返回当前所打开的表数： TablesNum:=olemapinfo.eval('NumTables()') 你也可以直接调用Mapinfo菜单或按钮命令对地图窗口进行操作，如地图放大显示：oleMapinfo.RunMenuCommand(1705) 2. 建立客户自动化对象触发CallBack 基于OLE自动化开发的难点在于所谓的CallBack，Mapinfo服务器对客户程序地图窗口的反应叫CallBack，假如你在地图窗口中移动地图目标，Mapinfo能返回信息告诉你地图目标当前的坐标位置，这就是CallBack功能。如果你想定制自己的地图操作工具或菜单命令，你必须依靠CallBack。但是想捕获CallBack信息，你的客户程序必须具备接收CallBack信息的能力，为此需要在客户程序中定义自己的OLE自动化对象，如： //定义界面 IMyCallback = interface(IDispatch) ['{2F4E1FA1-6BC7-11D4-9632-913682D1E638}'] function WindowContentsChanged(var WindowID: Integer):SCODE;safecall; function SetStatusText(var StatusText: WideString): SCODE; safecall; //定义界面实现
Struts2+Hibernate架构技术教程课后参考答案
第1章Struts2框架技术入门 1.5 习题 1.5.1 选择题 1.D 2.A 3.C 4.B 5.B 1.5.2 填空题 1.MVC 2.Struts1和WebWork 3.IBM 4. FilterDispatcher 5.JSP、Struts2标签 1.5.3 简答题 1.简述MVC设计模式的工作流程。 答：MVC设计模式工作流程是： （1）用户的请求（V）提交给控制器（C）； （2）控制器接受到用户请求后根据用户的具体需求，调用相应的JavaBean或者EJB（M部分）来进行处理用户的请求； （3）控制器调用M处理完数据后，根据处理结果进行下一步的调转，如跳转到另外一个页面或者其他Servlet。 2.简述Struts2的工作原理。 答：Struts2中使用拦截器来处理用户请求，从而允许用户的业务控制器Action与Servlet分离。用户请求提交后经过多个拦截器拦截后交给核心控制器FilterDispatcher处理，核心控制器读取配置文件struts.xml，根据配置文件的信息指定某一个业务控制器Action（POJO类）来处理用户数据，业务控制器调用某个业务组件进行处理，在处理的过程中可以调用其他模型组件共同完成数据的处理。Action处理完后会返回给核心控制器FilterDispatcher一个处理结果，核心控制器根据返回的处理结果读取配置文件struts.xml，根据配置文件中的配置，决定下一步跳转到哪一个页面。 一个客户请求在Struts2框架中处理的过程大概有以下几个步骤： （1）客户提交请求到服务器； （2）请求被提交到一系列的过滤器过滤后最后到FilterDispatcher； FilterDispatcher是核心控制器，是基于Struts2中MVC模式的控制器部分； （3）FilterDispatcher读取配置文件struts.xml，根据配置信息调用某个Action来处理客户请求； （4）Action执行完毕，返回执行结果，根据struts.xml的配置找到对应的返回结果。
Maya从入门到精通经典讲解
Maya绝技83式从入门到精通 第1招、自制MAY A启动界面 在安装目录下的BIN文件夹中的MayaRes.dll文件，用Resource Hacker打开。在软件的目录树中找到“位图”下MAY ASTARTUPIMAGE.XPM并保存。图片分辨率要一致，然后选择替换位图，把自己修改的图片替换保存，即可。 第2招、控制热盒的显示 MAYA中的热盒可以按着空格键不放，就可以显示出来。并且按下鼠标左键选择Hotbox Style 中的Zones Only可以不让热盒弹出。如果选择Center Zone Only可以连AW的字样也不会出现。完全恢复的快捷键是ALT+M。 第3招、创建多彩的MAY A界面 MAYA默认界面色彩是灰色的，如果你想尝试一下其他的色彩界面，可以自行修改。方法是选择Windows/Settings/Preferences/Colors... 第4招、创建自己的工具架 把自己最常用的工具放置在工具架的方法是，按下Ctrl＋Shift的同时，点选命令，该命令就可以添加到当前的工具架上了。 第5招、自定义工具架图标 我们将一行MEL添加到工具架上的时候，图标出现MEL字样，不容易区分，此时可以选择Windows/Settings/Preferences/Shelves选择新添加的命令，单击Change Image按钮，选择要替换的图片，选择Save All Shelves按钮，就替换成功。 第6招、自定义标记菜单 执行Windows/Settings/Preferences/Marking Menus设置相关参数，然后在Settings下符合自己操作习惯来设置参数，最后单击Save即可。 第7招、自定义物体属性 如果想添加一个属性，并且把其他数据进行设置表达式或者驱动关键帧，就必须在属性对话框中点击Attributes/add... 第8招、选择并且拖动 打开Windows/Settings/Preferences在Selection中，勾选Click Drag Select然后点击Save这样就可以了。 第9招、界面元素隐藏或显示 执行Display/UI Elements下的Show UI Elements或者Hide UI Elements可以对于全界面下元素显示或者隐藏。 第10招、改变操纵器的显示大小与粗细 打开Windows/Settings/Preferences在Manipulators中修改Line Size可以改变操纵器的显示粗细，按下小键盘的“+”“-”可以改变操纵器的显示大小。
WGCNA新手入门笔记2(含代码和数据)
WGCNA新手入门笔记2（含代码和数据） 上次我们介绍了WGCNA的入门（WGCNA新手入门笔记（含代码和数据）），大家在安装WGCNA包的时候，可能会遇到GO.db这个包安装不了的问题。主要问题应该是出在电脑的防火墙，安装时请关闭防火墙。 如果还有问题，请先单独安装AnnotationDbi这个包，biocLite("AnnotationDbi") 再安装GO.db，并尝试从本地文件安装该包。 如果还有问题，请使用管理员身份运行R语言，尝试上述步骤。 另外如果大家问题解决了请在留言处留个言，告知大家是在哪一步解决了问题，谢谢！因为本人没有进行单因素实验，不知道到底是哪个因素改变了实验结果。。。 今天给大家过一遍代码。网盘中有代码和数据。 链接：https://www.wendangku.net/doc/ba10878063.html,/s/1bpvu9Dt 密码：w7g4 ##导入数据## library(WGCNA)options(stringsAsFactors = FALSE)enableWGCNAThreads()
enableWGCNAThreads()是指允许R语言程序最大线程运行，像我这电脑是4核CPU的，那么就能用上3核： 当然如果当前电脑没别的事，也可以满负荷运作 samples=read.csv( 'Sam_info.txt',sep = 't',https://www.wendangku.net/doc/ba10878063.html,s = 1)expro=read.csv( 'ExpData.txt',sep = 't',https://www.wendangku.net/doc/ba10878063.html,s = 1)dim(expro) 这部分代码是为了让R语言读取外部数据。当然了在读取数据之前首先改变一下工作目录，这一点在周二的文章中提过了。R语言读取外部数据的方式常用的有read.table和read.csv，这里用的是read.csv，想要查看某一函数的具体参数，可以用？函数名查看，比如： 大家可以注意到read.table和read.csv中header参数的默认值是不同的，header=true表示第一行是标题，第二行才是数据，header=false则表示第一行就是数据，没有标题。##筛选方差前25%的基因## m.vars=apply(expro, 1,var)expro.upper=expro[which(m.vars>quantile(m.vars, probs = seq( 0, 1, 0.25))[ 4]),]dim(expro.upper)datExpr= as.data.frame(t(expro.upper));nGenes = ncol(datExpr)nSamples = nrow(datExpr) 这一步是为了减少运算量，因为一个测序数据可能会有好几
Spring 4 整合 Hibernate 5 技术
Spring 4 整合Hibernate 5 技术 在J2EE开发平台中，spring是一种优秀的轻量级企业应用解决方案。Spring的核心技术就是IOC控制反转和AOP面向切面编程技术。 下面给出一个项目代码示例对Sping的相关技术进行讲解，该项目代码整合了最新的Spring4.2.5和Hibernate5.1技术，项目代码结构图如下：
下面给出详细配置代码 [html]view plain copy 1.package com.kj.test.domain; 2. 3.import java.io.Serializable; 4. 5./** 6. * 用户实体类 7. * @author KJ 8. * 9. */ 10.public class User implements Serializable{ 11. 12. private static final long serialVersionUID = 7178219894611819140L; 13. /** 性别 */ 14. public static final int MAN = 1; //男 15. public static final int FEMAN = 2; //女 16. 17. private Long id; 18. /** 姓名 */ 19. private String name; 20. /** 性别 */ 21. private Integer sex; 22. /** 年龄 */ 23. private Integer age; 24. 25. public User () {
Angular2 入门
Angular2 入门 快速上手 Why Angular2 Angular1.x显然非常成功，那么，为什么要剧烈地转向Angular2？ 性能的限制 AngularJS当初是提供给设计人员用来快速构建HTML表单的一个内部工具。随着时间的推移，各种特性被加入进去以适应不同场景下的应用开发。然而由于最初的架构限制（比如绑定和模板机制），性能的提升已经非常困难了。 快速变化的WEB 在语言方面，ECMAScript6的标准已经完成，这意味着浏览器将很快支持例如模块、类、lambda表达式、generator等新的特性，而这些特性将显著地改变JavaScript的开发体验。 在开发模式方面，Web组件也将很快实现。然而现有的框架，包括Angular1.x对WEB组件的支持都不够好。 移动化 想想5年前......现在的计算模式已经发生了显著地变化，到处都是手机和平板。Angular1.x没有针对移动应用特别优化，并且缺少一些关键的特性，比如：缓存预编译的视图、触控支持等。 简单易用 说实话，Angular1.x太复杂了，学习曲线太陡峭了，这让人望而生畏。Angular 团队希望在Angular2中将复杂性封装地更好一些，让暴露出来的概念和开发接口更简单。 Rob Eisenberg / Angular 2.0 Team
ES6工具链 要让Angular2应用跑起来不是件轻松的事，因为它用了太多还不被当前主流浏览器支持的技术。所以，我们需要一个工具链： Angular2是面向未来的科技，要求浏览器支持ES6+，我们现在要尝试的话，需要加一些垫片来抹平当前浏览器与ES6的差异： ?angular2 polyfills - 为ES5浏览器提供ES6特性支持，比如Promise 等。 ?systemjs - 通用模块加载器，支持AMD、CommonJS、ES6等各种格式的JS模块加载 ?typescript - TypeScript转码器，将TypeScript代码转换为当前浏览器支持的ES5 代码。在本教程中，systemjs被配置为使用TypeScript转码器。 ?reactive extension - javascript版本的反应式编程/Reactive Programming实现库，被打包为systemjs的包格式，以便systemjs动态加载。 ?angular2 - Angular2框架，被打包为systemjs的包格式，以便systemjs 动态加载模块。 处于方便代码书写的考虑，我们将这些基本依赖打包到一个压缩文件中：?angular2.beta.stack.min.js
Struts2+Hibernate框架技术教程课后习题答案(张志峰主编)
1.5习题(第33页) 1.5.1选择题 D C C B B 1.5.2填空题 1.MVC 2.Struts Hibernate 3.IBM 4.FilterDispatcher 5. JSP Struts标签 2.7习题（第86页） 2.7.1选择题 B C B D B D 2.7.2填空题 1.struts.xml struts.properity 2.struts.xml struts.properity web.xml 3.Action 拦截器 4.完全分离 5.IOC和非ioc 6.不指定method 不指定method 7.表达式根对象上下文环境 8.UI标签非UI标签 9.表单标签非表单标签 10.控制标签数据标签 3.6习题（第133页） 3.6.1选择题 A A B C C 3.6.2填空题 1..properties 2.native2ascii 3.AOP 4.服务器端校验 5.5习题（第237页） 5.5.1选择题 A B A 5.5.2填空题 1. JDBC ORM
2. Hibernate.cfg.xml Hibernate.properities 3. Hibernate.hbm.xml 4. 临时状态持久状态脱管状态 7.6习题（第326页） 6.11.1选择题 B A C 6.11.2填空题 1.一对一一对多多对多 2.HQL Criteria query native sql 3.一级cache 二级cache Spring3 9.5习题 9.5.1选择题 B A C 9.5.2填空题 1.配置条件 2.bean factory接口及相关类 application contest接口及相关类 3.设置注入构造注入 10.7.1选择题 B D C 10.7.2填空题 1.静态AOP 动态AOP 2.通知 3.静态代理动态代理 4.前置通知后置通知
hibernate分页技术
使用扩展HibernateDaoSupport实现分页技术总结 1.定义MyHibernateDaoSupport 扩展HibernateSupport mport java.sql.SQLException; import java.util.List; import org.hibernate.HibernateException; import org.hibernate.Query; import org.hibernate.Session; import org.springframework.orm.hibernate3.HibernateCallback; import org.springframework.orm.hibernate3.support.HibernateDaoSupport; public class MyHibernateDaoSupport extends HibernateDaoSupport { public List findByPage(final String hql,final int offset,final int pageSize) { List list=this.getHibernateTemplate().executeFind(new HibernateCallback() { public Object doInHibernate(Session session) throws HibernateException, SQLException { List result=session.createQuery(hql).setFirstResult(offset).setMaxResults(page Size).list(); return result; } } ); return list; } public List findByPage(final String hql,final String value,final int offset,final int pageSize)
hibernate(api_介绍)
Hibernate API 1 接口类型 1．访问数据库的各种操作的接口 包括Session、Transaction、Query接口。 2．配置Hibernate的接口 Configuration接口。 3．回调接口 使应用程序能够监听Hibernate内部发生的各种事件，并做出相应的回应。 包括Interceptor接口。 4．映射类型接口 Java数据类型和数据库数据类型的映射，如Type、CompositeUserType等接口。 5．扩展接口 功能扩展，如Dialect、IdentifierGenerator等。 Hibernate内部封装了JDBC(Java Database Connector)、JTA(Java Trasaction API)、JNDI(Java Naming and Directory Interface)。我们只要提供JDBC驱动程序就可以通过Hibernate访问任何数据库系统。 1.1 核心接口 1．org.hibernate.cfg.Configuration Interface 配置并根启动Hibernate。通过该接口来指定Hibernate配置文件(hibernate.cfg.xml 或者hibernate.properties)的位置或动态配置Hibernate的属性，接着创建SessionFactory。 2．org.hibernate.SessionFactory Interface 从该接口中获得Session实例，具备以下特点： a. 多线程安全 b. 重量级，一个数据库对应一个SessionFactory，其创建及销毁消耗资源多。 3．org.hibernate.Session Interface 和我们前面所学的HttpSession没有任何关系。我们在Hibernate应用中使用最广泛的接口。也被称为持久化管理器，提供了相关的数据库操作，比如添、更、删、加、查等基本操作。 特点： a. 非线程安全。 b. 轻量级，其创建及销毁消耗资源少。每个客户请求对应一个Session。 4．org.hibernate.Transaction Interface 封装了底层事务接口。底层事务接口包括： a. JDBC API b. JTA c. CORBA(Common Object Request Broker Architecture) API 5．org.hibernate.Query 和org.hibernate.Criteria Interface 查询接口。用于向数据库查询对象以及控制执行查询的过程。Query封装了HQL(Hibernate Query Language)查询语句，和SQL很类似，唯一的区别在于HQL是面向对象的。 Criteria完全封装了基于字符串形式的查询语句，更加面向对象，擅长执行动态查询，即参数查询。 1.2 回调接口 org.hibernate.Interceptor Interface
Allegro入门总结
参考资料：于博士 cadence视频教程，入门的主要资源。 1 Cadence高速电路板设计与仿真周润景 2 使用的软件为：cadence 16.3，学习目录跟2的目录一致。 一、cadence原理图设计平台 这里使用的cadence原理图设计平台是Design Entry CIS，在使用上比较方便简单，跟protel 相似，主要是跟于博士的教程没有什么出入，按照视频教程基本上看两遍就可以学会了。对于工具的使用自己摸索摸索多数功能也能实现。没有太多容易遗忘的地方。 原理设计流程： 1、建立元件库，这里仅仅使用一些基本的方法建立元件； 在Capture Design CIS，file->new->Library,可以新建一个元件库用来存储自己的元件符号。选择xxx.olb文件，右键new part就可以添加自己的元件； 在原理图工作环境中把自己建立的库选入列表中就可以跟使用自带的元件库一样。 此外常用的库有：Discrete.olb、MicroController.olb、Conector.olb、Gate.olb；添加方法是“Place Part” 对话框中的Library中点击添加；（只有两个按钮，一个删除，一个添加）。 在原理图制作中，需要注意栅格选定，如果放置时引脚没有选定，绘出的元件在原理图中很难连线。绘制元件图用到的操作一般在Option里面，其他放置引脚，元件框，都在右边的工具栏中； 2、放置元件，连接成原理图，主要是网络和层次电路图的使用；
File->new->project命令建立新的原理图，选择sch即可。至于其他的操作方法比较符合人的思维习惯，把于博士的视频教程看一遍估计就可以记住了。 3、封装填写，可以批量填写，这个功能很有用； 批量填写，具体操作时把元件都选中后，右键Edit Propertion，在footprint选项中，想使用excel一样，填写即可； 4、DRC检查和元件的标号标注； 在进行这些操作时需要选中DSN文件，另外在于博士的教程中详细讲解了Edit->browse 命令的用法，很是受用； 5、导出网络列表； 跟上面一样需要选择dsn文件。 二、cadence封装的制作 由于cadence封装对制版关系重大，且不容易检查，这里不做简要介绍。于博士的视频教程跟实际使用基本没有出入，按照教程做几个封装基本就会掌握。封装的制作工具是 pad designer和allegro PCB design GXL16.3，这个版本跟于博士教程中师范的版本有较大的出入。在使用时往往需要添加自己封装库，添加方法是：Setup->User Preferences Dailog,z在这个对话框中选择Paths->Library，在里面设置padPath和psmPath即可。选择自己建立封装的文件夹，这样在Place Manuly里面就可以看到，需要把library选上。 这里对paddesigner中的一些概念明确一下： 1、PAD有三种 1）Regular Pad ，规则焊盘（正片中），有圆形（Circle）、方形(Square)、Oblong(拉长圆形)、方形(Rectang)、Octagon(八边形)、任意形状（Shape）；
- 第21章_Hibernate的高级技术 试验设计与数据处理教案(第二版)课件
- 基于Hibernate技术的持久层解决方案及实现
- Hibernate技术
- 第5章 Hibernate持久层技术(3)
- 最新hibernate技术课程讲解
- hibernate分页技术
- Hibernate常见概念以及关键技术
- 第5章 Hibernate持久层技术(2)
- Spring框架和Hibernate框架相互整合的技术实现
- Struts2+Hibernate架构技术教程课后参考答案
- struts2hibernate架构技术教程课后参考答案
- Hibernate数据缓存技术
- Spring 4 整合 Hibernate 5 技术
- hibernate(api_介绍)
- 利用轻量对象关系映射技术Hibernate提高开发效率
- Struts2+Hibernate框架技术教程课后习题答案(张志峰主编)
- hibernate和spring框架技术难点及其要点总结
- 持久层设计技术hibernate_leon
- Hibernate技术