JXTA中定义自己的成员服务
http://blog.csdn.net/neusoftware_20063500/article/details/4302903
——————————————————————————————————————————————————————————————————————————
成员服务：MemberShipService
这个服务是点组用于管理成员的一项服务，既然是服务就可以自己装载和卸载，我们的目的就是定义自己的规则，符合自定义规则的成员可以加入组，否则不可以。所以我们需要实现三个实现类，MemberShipService的实现类、Credential的实现类，Authenticator的实现类。然后需要将成员服务装载到组中，组中的服务继承于父组，所以如果不自定义自己的服务，就继承NetPeerGroup的服务，默认情况下成员服务不做任何验证工作，平台为我们默认实现了PasswdMemberShipService，用于验证密码，那么我们新建自己的组并且装载自己服务的过程如下：
1. 得到父组的ModuleImplAdvertisement
2. StructuredDocument paramDoc = advertisement.getParam()获得参数
3. StdPeerGroupParamAdv paramAdv = new StdPeerGroupParamAdv(paramDoc)封装为标准通告
4. Map services = paramAdv.getServices()得到服务，这些服务就是父组的所有服务
5. services.put(PeerGroup.membershipClassID, moduleAdv);将成员服务替换为自己的成员服务，替换key为membershipClassID的ModuleImplAdvertisement对象，那么如何构建自己服务的ModuleImplAdvertisement对象呢？
6. paramAdv.setServices(services);
7. advertisement.setParam((net.jxta.document.TextElement)paramAdv.getDocument(
new net.jxta.document.MimeMediaType(DOCUMENT_MIME_TYPE,
DOCUMENT_BASE_TYPE)));还原
8. peerGroup = parent.newGroup(peerGroupID, advertisement, groupName, groupDescription);
peerGroup.init(this.parent,peerGroupID, advertisement);
创建子组然后发布子组。
9. 下面是获得自己的成员服务ModuleImplAdvertisement 的方法
String moduleImplAdvType = ModuleImplAdvertisement.getAdvertisementType();
ModuleImplAdvertisement implAdvertisement = (ModuleImplAdvertisement)
AdvertisementFactory.newAdvertisement(moduleImplAdvType);新建一个空的
implAdvertisement.setModuleSpecID(PeerGroup.refMembershipSpecID);
implAdvertisement.setCompat(stdCompatStatement);
implAdvertisement.setCode(code);code是实现MemberShipService的完整类名
implAdvertisement.setUri(stdUri);
implAdvertisement.setProvider(stdProvider);
implAdvertisement.setDescription(descr); 填充信息
那么这样就替换了自己的服务，总体过程是获得父亲组的所有服务，从父亲组的通告（ModuleImplAdvertisement）中获得所有服务，然后将其中的具体某个服务替换成自己的服务（用ModuleImplAdvertisement标示），然后将服务重新设置到通告中，然后根据这个通告创建子组。那么此子组就有自己的成员服务了。
下面是Java P2P程序设计的实例代码：
GroupManager：
package com.sams.jxta.groups; import net.jxta.credential.AuthenticationCredential;
import net.jxta.credential.Credential;
import net.jxta.discovery.DiscoveryService;
import net.jxta.document.Advertisement;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.StructuredDocument;
import net.jxta.document.StructuredTextDocument;
import net.jxta.exception.PeerGroupException;
import net.jxta.exception.ProtocolNotSupportedException;
import net.jxta.id.IDFactory;
import net.jxta.impl.id.UUID.UUIDFactory;
import net.jxta.impl.protocol.PeerGroupAdv;
import net.jxta.peergroup.PeerGroupID;
import net.jxta.peergroup.PeerGroupFactory;
import net.jxta.impl.peergroup.StdPeerGroup;
import net.jxta.impl.peergroup.StdPeerGroupParamAdv;
import net.jxta.membership.Authenticator;
import net.jxta.membership.MembershipService;
import net.jxta.peergroup.PeerGroup;
import net.jxta.platform.ModuleClassID;
import net.jxta.protocol.ModuleImplAdvertisement;
import net.jxta.protocol.PeerGroupAdvertisement; import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Map; /**
* This class can be used to create a new group with a pluggable
* Membership service.It provides simple APIs for Apply,Join and Resign
* functionalities.
*/ public class GroupManager { private static final org.apache.log4j.Category LOG =
org.apache.log4j.Category.getInstance(GroupManager.class.getName());
protected DiscoveryService disco;
// The parent group of the current peer group
protected PeerGroup parent;
// Net peer for creating advertisements.
protected PeerGroup netPeerGroup;
// The current peer group
protected PeerGroup activeGroup;
// Any module(like a peer group) that is loaded by the parent group,must
// be compatible with the parent.Compatibility is checked by comparision
// with the stdCompactStatement
public StructuredTextDocument stdCompatStatement = // ??? Taken from StdPeerGroup
mkCS();
// An identifier to the implementation used // ??? Is it so ?
public String stdUri = "http://www.jxta.org/download/jxta.jar";// ??? Taken from StdPeerGroup
// The provider of the implementation // ??? Is it so ?
public String stdProvider = "sun.com";// ??? Taken from StdPeerGroup // The mime type of all documents used in this example
public static final String DOCUMENT_MIME_TYPE="text";
// The base type of all documents
public static final String DOCUMENT_BASE_TYPE="xml";
// This is the root element documents created
public static final String DOCUMENT_ROOT_ELEMENT="Comp";
// Key ??? What is this used for ?
private static final String KEY="Efmt";
// Value ??? What is this used for ?
private static final String VALUE="JDK1.4";
// Key used to represent the binding
private static final String BINDING_KEY="Bind";
// Value of the binding key.It represents the binding
// of JXTA that we use.
private static final String BINDING_VALUE="V1.0 Ref Impl"; /**
* The constructor of the Group Manger.Initially
* the parent group is the also the active group.
*/ public GroupManager(PeerGroup netPeerGroup, PeerGroup parent) { this.disco = parent.getDiscoveryService();
this.parent = parent;
this.activeGroup = parent;
this.netPeerGroup = netPeerGroup;
if (netPeerGroup == null){
System.out.println("netPeerGroup :"+netPeerGroup+" - aborting");
throw new NullPointerException("netPeerGroup :"+netPeerGroup+" - aborting");
}
} /*
* Method to add a new peer group and publish it.The
* groupMemebershipClassName is the fully qualified class
* name of the mermbership service class.
*
*/ public PeerGroup addGroup(String groupName,String groupMembershipClassName,
String groupDescription,
ModuleImplAdvertisement advertisement,
boolean conditional){
System.out.println("GroupManager.addGroup Successfully created SecurityDemoGroup");
// The first thing we do is to see if a group already exists by this name.
// If so we get the Group ID of the group. Then depending on the unconditional
// flag we proceed.
// If it is an conditional add ,we create a new group only if no other group
// with the same name already exists otherwise we throw an exception.
// If it is an unconditional add , we always create a group.If the user had previously
// created the group , we use the Old group ID .
PeerGroupID oldPeerGroupID = alreadyExists(groupName);
if(oldPeerGroupID != null && conditional==true)
throw new GroupManagerException("A Group by this name already exists with id :"
+oldPeerGroupID); // If no Advertisement is provided, we create a fresh advertisement.
if (advertisement == null){
LOG.debug("Creating a new Advertisement");
// We use the existing advertisement of the standard peer group
// and add our service along with the other standard services
try{
// This is used as a base to create the new advertisement upon
System.out.println("netPeerGroup :"+netPeerGroup);
advertisement = netPeerGroup.getAllPurposePeerGroupImplAdvertisement();
//advertisement = parent.getAllPurposePeerGroupImplAdvertisement();//<< Did not work in current platform
StructuredDocument paramDoc = advertisement.getParam();
System.out.println("StructuredDocument paramDoc:"+paramDoc);
// The Param document used to make the StandradPeerGroup Advertisement
StdPeerGroupParamAdv paramAdv = new StdPeerGroupParamAdv(paramDoc);
// List of all the available standard services
Map services = paramAdv.getServices();
// Make a ModuleImplAdvertisemnet for the membership service
ModuleImplAdvertisement moduleAdv =
mkImplAdvBuiltin(PeerGroup.refMembershipSpecID,groupMembershipClassName,
groupDescription);
// Add this service along the other standard services
services.put(PeerGroup.membershipClassID, moduleAdv);
paramAdv.setServices(services);
advertisement.setParam((net.jxta.document.TextElement)paramAdv.getDocument(
new net.jxta.document.MimeMediaType(DOCUMENT_MIME_TYPE,
DOCUMENT_BASE_TYPE)));
System.out.println("compat " + advertisement.getCompat());
System.out.println("compat " + StdPeerGroup.STD_COMPAT);
}catch(PeerGroupException peerGroupException){
peerGroupException.printStackTrace();
System.exit(-1);
LOG.error("Error in creating Advertisement",peerGroupException);
throw new GroupManagerException(peerGroupException.getMessage());
}catch(Exception genericException){
genericException.printStackTrace();
LOG.error("Error in creating Advertisement",genericException);
System.exit(-1);
throw new GroupManagerException(genericException.getMessage());
}
}
LOG.debug("Successfullt created ADVERTISEMENT"); // initialize but to no start the application
// this is done by the join command
LOG.debug("Creating the Peer Group");
PeerGroup peerGroup = null;
try {
// create a PeerGroup ID
PeerGroupID peerGroupID = null;
if(oldPeerGroupID != null){
peerGroupID = oldPeerGroupID;
}else{
peerGroupID = IDFactory.newPeerGroupID();
}
// create the PeerGroup
peerGroup = parent.newGroup(peerGroupID, advertisement, groupName, groupDescription);////
// initialize the peergroup
peerGroup.init(this.parent,peerGroupID, advertisement);
} catch (PeerGroupException peerGroupException) {
peerGroupException.printStackTrace();
LOG.error("Unable to create a peer group !",peerGroupException);
throw new GroupManagerException(peerGroupException.getMessage());
}
// For debug purposes, print advertisement to console
//com.sams.jxta.Util.printAdvertismentDoc(advertisement);
// Try to publish the advertisement
LOG.debug("Trying to publish the advertisement");
publish(peerGroup, advertisement/*original advertisement???*/);
LOG.debug("Peer Group Advertisement successfully published");
return peerGroup; } /**
* Will check if a peer group with the same name exists on this peer
*/ public PeerGroupID alreadyExists(String name){ DiscoveryService discovery = parent.getDiscoveryService();
Enumeration enumeration =null;
try{
enumeration =
discovery.getLocalAdvertisements(discovery.GROUP, "Name",name);
} catch(java.io.IOException ioException) {
LOG.debug("Error in getting local advertisements ");
return null;
}
// If the group already exists either the enumeration is null
// or it does not contain any data if(enumeration != null && enumeration.hasMoreElements())
return ((PeerGroupAdv)enumeration.nextElement()).getPeerGroupID();
else
return null;
} // Tries to publish the newly created peer group
// ??? Why do we need the original Advertisement ?
private void publish(PeerGroup child,Advertisement pgAdv
//PeerGroupAdvertisement origAdv
) {
System.out.println("Publishing group");
//get the Discovery for this group
//Publish the New Peer in its group discovery DiscoveryService discovery;
try {
discovery = parent.getDiscoveryService();
discovery.publish(pgAdv);
// let's publish the peer adv
//if (origAdv != null){//?????? Not sure what this does
// we could check if it is indeed ours
// but it does not hurt to publish it any way
// discovery = child.getDiscoveryService();
// discovery.publish(origAdv, DiscoveryService.GROUP);
//}
} catch (java.io.IOException ioException) {
LOG.error("Could not publish the service !",ioException);
throw new GroupManagerException(ioException.getMessage());
}
LOG.debug("Published the group successfully");
} /**
* This is the code that will create a credential to join the group.
* Each group that we are joining has a specific membership requirement.
* Many groups will just be the NullMembership, which is the default.
*
*/ public Credential joinGroup(PeerGroup newGroup,StructuredDocument credentials,
String authenticationMethod)
throws GroupManagerAuthenticationException,
ProtocolNotSupportedException{ MembershipService membership = (MembershipService) newGroup.getMembershipService();
// The first step is to apply to the membership service
Authenticator authenticator;
authenticator = applyToMembershipService(newGroup,credentials,authenticationMethod);
// Next step is to allow the user to "fill up" the authenticator
// by creating a dialog
LOG.debug("Apply process successful");
authenticate(authenticator);
// third , try to join the service
Credential authenticatedCredential =joinMembershipService(authenticator,newGroup); // All is fine ! We can switch to the new group
activeGroup = newGroup;
LOG.debug("JOIN SUCCESSFUL !");
return authenticatedCredential; } /**
* This code demonstrates how to apply to a membership service.
*/ private Authenticator applyToMembershipService(PeerGroup peerGroup,
StructuredDocument credentials,
String authenticationMethod)
throws GroupManagerAuthenticationException,
ProtocolNotSupportedException{
Authenticator authenticator = null;
// Here we create an authentication credential and
// try to apply for a Authenticator.An exception is thrown in case
// this step fails.
try { AuthenticationCredential authenticationCredential =
new AuthenticationCredential(peerGroup,authenticationMethod,credentials );
MembershipService membership = (MembershipService) peerGroup.getMembershipService();
authenticator = (Authenticator)membership.apply( authenticationCredential ); } catch( PeerGroupException peerGroupException ) {
// This denotes a failure in the Apply process.We
// consider this as an Authentication exception.
LOG.error("Apply process failed !! ",peerGroupException);
throw new GroupManagerAuthenticationException(peerGroupException.getMessage());
} catch (ProtocolNotSupportedException protocolNotSupportedException){
LOG.error(protocolNotSupportedException);
throw protocolNotSupportedException;
}
return authenticator;
} /**
* This method will help the user to actually "fill up" the authenticator
* details. It will display a dialog and enable the user to visually
* provide details to each parameter of the Authenticator.The parameters
* of the Authenticator are found by Introspection.
*/ private void authenticate( Authenticator authenticator ){
// The following bean looks for standard bean parameters to create the
// contents to set the authenticator. There is no real spec so this
// will have to do.
AuthenticatorBean viewBean = new AuthenticatorBean(null,
true,authenticator,
"Please Enter Required Group Info");
viewBean.setVisible(true);
} /**
* This code demonstrates how to join a membership service.
*/ private Credential joinMembershipService(Authenticator authenticator,
PeerGroup peerGroup)
throws GroupManagerAuthenticationException { Credential authenticatedCredential = null;
// We check if the user is authentic
if( !authenticator.isReadyForJoin() ) {
LOG.error( "Authenticator is not ready to join");
throw new GroupManagerAuthenticationException("Authenticator is not ready to join !");
} // Since the user is authentic , we allow the
// user to join the service.But the service may reject the
// user as well. try{
MembershipService membership = (MembershipService) peerGroup.getMembershipService();
authenticatedCredential= membership.join(authenticator);
} catch(PeerGroupException peerGroupException) {
LOG.error( "Error in the Join Process",peerGroupException);
throw new GroupManagerAuthenticationException("Error in the Join Process");
}
return authenticatedCredential;
} /**
* Method used to quit the current active group.
*/ public void leaveGroup(){ MembershipService memberShipService = activeGroup.getMembershipService();
try{
memberShipService.resign();
} catch(PeerGroupException peerGroupException){
LOG.error("Exception in resign",peerGroupException);
throw new GroupManagerException(peerGroupException.getMessage());
}
activeGroup = parent;
purgeGroups();
} /*
* The method to renew the membership to the currently active group.
*/ public void renew(Credential credential){
// ??? Seems that the implementation does not have a concept of renewal
} /**
* Purge all groups from the cache. This help prevent us from creating
* a copy of a group with the same ID.
*
*/ public void purgeGroups(){
DiscoveryService discovery = parent.getDiscoveryService();
try{
discovery.flushAdvertisements(null,DiscoveryService.GROUP);
} catch (java.io.IOException ioException) {
LOG.error("Error in purging Groups",ioException);
throw new GroupManagerException(ioException.getMessage());
}
} /**
* Creates an ModuleImplAdvertisement which in this context is a
* MembershipService.
*
*/ private ModuleImplAdvertisement mkImplAdvBuiltin(
net.jxta.platform.ModuleSpecID specID,
String code,String descr) { String moduleImplAdvType = ModuleImplAdvertisement.getAdvertisementType();
ModuleImplAdvertisement implAdvertisement = (ModuleImplAdvertisement)
AdvertisementFactory.newAdvertisement(moduleImplAdvType);
implAdvertisement.setModuleSpecID(specID);
implAdvertisement.setCompat(stdCompatStatement);
implAdvertisement.setCode(code);
implAdvertisement.setUri(stdUri);
implAdvertisement.setProvider(stdProvider);
implAdvertisement.setDescription(descr);
return implAdvertisement;
} /**
* Creates a compatibility segment for a ModuleImplAdvertisement.
* This is needed so that our parent group can load modules of the
* reference implementation also.
*/ //??? Taken from StdPeerGroup because it was private. This should have
//* been in a utility class.
protected StructuredTextDocument mkCS() { StructuredTextDocument doc = (StructuredTextDocument)
net.jxta.document.StructuredDocumentFactory.newStructuredDocument(
new net.jxta.document.MimeMediaType(DOCUMENT_MIME_TYPE,
DOCUMENT_BASE_TYPE),
DOCUMENT_ROOT_ELEMENT);
net.jxta.document.Element e = doc.createElement(KEY, VALUE);
doc.appendChild(e);
e = doc.createElement(BINDING_KEY, BINDING_VALUE);
doc.appendChild(e);
return doc;
} /**
* This method is used for refreshing the peer with remotely published advertisements.
* //???Makes little sense without a listener.Moreover the method is deprecated
*/ public void refreshGroups(){ //disco.getRemoteAdvertisements(null, DiscoveryService.GROUP, null, null,100);
} /*
* Method used to get the currently active group.
*/ public PeerGroup getActiveGroup(){ return activeGroup;
}
}
UniversityAdmissionsService
package com.sams.jxta.groups.student; import net.jxta.membership.MembershipService;
import net.jxta.membership.Authenticator;
import net.jxta.credential.Credential;
import net.jxta.credential.AuthenticationCredential;
import net.jxta.exception.PeerGroupException;
import net.jxta.exception.ProtocolNotSupportedException;
import net.jxta.discovery.DiscoveryService;
import net.jxta.document.Element;
import net.jxta.document.Advertisement;
import net.jxta.id.ID;
import net.jxta.impl.membership.passwd.PasswdMembershipService;
import net.jxta.peergroup.PeerGroup;
import net.jxta.protocol.ModuleImplAdvertisement;
import net.jxta.service.Service;
import net.jxta.document.StructuredDocument; import java.util.Vector; import java.util.Enumeration; /*
* A Membership Service designed to represent the Admission Process in a Univeristy.
*/ public class UniversityAdmissionsService extends PasswdMembershipService{ public UniversityAdmissionsService() throws PeerGroupException {
super();
} private static final org.apache.log4j.Category LOG =
org.apache.log4j.Category.getInstance(UniversityAdmissionsService.class.getName());
private PeerGroup peerGroup;
private ModuleImplAdvertisement implAdv;
private ID assignedID;
private Vector invitationLetters = new Vector();
private Vector authenticationCredentials = new Vector(); /*
* This method is called during an apply process.
*/ public Authenticator apply( AuthenticationCredential unsubscribedCredential )
throws PeerGroupException, ProtocolNotSupportedException{ String method = unsubscribedCredential.getMethod(); if( (null != method) && !"PreApplication".equals( method ) )
throw new ProtocolNotSupportedException(
"Authentication method not recognized : Required /"PreApplication/" ");
StructuredDocument preApForm =
(StructuredDocument)unsubscribedCredential.getIdentityInfo();
Enumeration enums = preApForm.getChildren();
Element element = (Element) enums.nextElement();
String departmentAppliedFor =(String) element.getValue();
// Vacancies exist only in the Computer Science Department
if(!departmentAppliedFor.equals(PreApplicationForm.DEPARTMENT_COMPUTER_SCIENCE))
throw new PeerGroupException("No Admissions to this Department(code:"+departmentAppliedFor+")");
ApplicationForm applicationForm = new ApplicationForm(this,unsubscribedCredential);
return applicationForm; } /*
* This method is called when the peer is interested in joining the peer group.
*/ public Credential join(Authenticator authenticated )throws PeerGroupException{ ApplicationForm applicationForm = (ApplicationForm)authenticated;
// We double check that the Authentiction is indeed successful
if(!applicationForm.isReadyForJoin())
throw new PeerGroupException("Application Form rejected !!");
// this means that the person can be taken in
InvitationLetter invitationLetter = new InvitationLetter(this);
invitationLetters.addElement(invitationLetter);
authenticationCredentials.addElement(authenticated.getAuthenticationCredential());
return invitationLetter;
} /*
* This method is called when the peer leaves the group.
* Here we destroy all previous records of Authentication
* Credentials and Credentials
*/
public void resign(){
//Destory all records
invitationLetters = new Vector();
authenticationCredentials = new Vector();
} /*
* Returns all the Credentials for this peer
*/
public Enumeration getCurrentCredentials(){
return invitationLetters.elements();
} /*
* Returns all the Authentication Credentials for this peer
*/
public Enumeration getAuthCredentials(){
return authenticationCredentials.elements();
} /*
* Returns the ModuleImplAdvertisement
*/
public Advertisement getImplAdvertisement(){
return implAdv;
} /*
* This method is called when the module is initialized.
*/
public void init(PeerGroup peerGroup,
ID assignedID,
Advertisement implAdv)
throws PeerGroupException{ this.peerGroup = peerGroup;
this.assignedID=assignedID;
this.implAdv=(ModuleImplAdvertisement)implAdv;
} /*
* Getter method for the peer group
*/
public PeerGroup getPeerGroup(){
return peerGroup;
} /*
* Getter for the Interface.For the sake of simplicity ,
* this object acts as it's own interface.
*/
public Service getInterface() {
return this;
} /*
* Methods to be implemented by virtue of being a module.
* Not used in this example
*/ public int startApp(String[] args){return 0;} public void stopApp(){} /*
* This method is currently not supported .//??? Is this OK ?
*/
public Credential makeCredential( Element element )
throws PeerGroupException, Exception{
return null;
} }
PreApplicationForm
package com.sams.jxta.groups.student; import net.jxta.document.Element;
import net.jxta.document.MimeMediaType;
import net.jxta.document.StructuredDocument;
import net.jxta.document.StructuredDocumentFactory; /*
* A Pre Application Form is used as an identity info in the
* Authentication Credential.
*
*/ public abstract class PreApplicationForm { public static final String DEPARTMENT_COMPUTER_SCIENCE = "CS";
public static final String DEPARTMENT_MANAGEMENT = "MT";
public static final String DEPARTMENT_ARCHITECTURE = "AT"; /*
* This methods creates a Structured Document representing the PreApp form.
* This serves as an IdentityInfo in the authentication credential.
*/
public static final StructuredDocument createPreAppForm(String department){ MimeMediaType type = new MimeMediaType("text","xml");
StructuredDocument doc =
StructuredDocumentFactory.newStructuredDocument( type,"PreAppForm" );
Element e = doc.createElement( "Department",department);
doc.appendChild( e );
return doc; }
}
InvitationLetter
package com.sams.jxta.groups.student; import net.jxta.credential.Credential;
import net.jxta.peergroup.PeerGroupID;
import net.jxta.peer.PeerID;
import net.jxta.service.Service;
import net.jxta.id.ID;
import net.jxta.membership.MembershipService;
import net.jxta.document.StructuredDocument;
import net.jxta.document.StructuredDocumentFactory;
import net.jxta.document.MimeMediaType;
import net.jxta.document.Element; /*
* This class represents a Credential that is supplied to a
* peer after a successful apply process.
*/
public class InvitationLetter implements Credential {
// Reference to the Membership Service
private UniversityAdmissionsService admissionsService; /*
* Constructor which takes a Membership Service Object
*/
public InvitationLetter(UniversityAdmissionsService admissionsService){ this.admissionsService = admissionsService;
}
/*
* Getter for the Membership Service
*/
public Service getSourceService(){ return admissionsService;
} /*
* This method returns the PeerGroup ID
*/
public ID getPeerGroupID(){
return admissionsService.getPeerGroup().getPeerGroupID();
} /*
* This method returns the Peer ID
*/
public ID getPeerID(){
return admissionsService.getPeerGroup().getPeerID();
} /*
* This method returns a Structured Document representing the Credential
*/
public StructuredDocument getDocument(MimeMediaType as) throws Exception { StructuredDocument doc =
StructuredDocumentFactory.newStructuredDocument( as,"InivtationLetter" ); Element e = doc.createElement( "PeerGroupID",
admissionsService.getPeerGroup().getPeerGroupID() );
doc.appendChild( e );
e = doc.createElement("TimeOfRequest",""+System.currentTimeMillis());
doc.appendChild( e );
return doc;
}
public Object getSubject() {
return null;
}
public boolean isExpired() {
return false;
}
public boolean isValid() {
return false;
}
}
ApplicationForm
package com.sams.jxta.groups.student; import net.jxta.membership.Authenticator;
import net.jxta.membership.MembershipService;
import net.jxta.credential.AuthenticationCredential; /*
* An Application Form represents an Authenticator.
*
*/
public class ApplicationForm implements Authenticator{ private String studentName;
private float GPA;
private UniversityAdmissionsService admissionsService;
private AuthenticationCredential unsubscribedCredential; /*
* Constructor
*/
public ApplicationForm(UniversityAdmissionsService admissionsService,
AuthenticationCredential unsubscribedCredential){
this.admissionsService = admissionsService;
this.unsubscribedCredential = unsubscribedCredential;
} /*
* Returns a String representing the method Name
*/
public String getMethodName(){
return "ApplicationForm";
} /*
* Returns the Authentication Credential
*/
public AuthenticationCredential getAuthenticationCredential(){
return unsubscribedCredential;
} /*
* Returns the Source Membership Service
*/
public MembershipService getSourceService(){
return admissionsService;
} /*
* This method checks if the Application Form is authenticated properly
* Only if the form is "filled" properly , can the peer join the Membership
* Service. Here we consider an Application Form as ready to join if
* the GPA is greater than 3.0 and a "non blank" name has been provided.
*
*/
public boolean isReadyForJoin(){
if(studentName == null || studentName.trim().equals(""))
return false;
if(GPA >3.0f)
return true;
else
return false;
} /*
* Setter for the GPA
*/
public void setGPA(float GPA){
this.GPA = GPA;
} /*
* Setter for the Student Name
*/
public void setStudentName(String studentName){
this.studentName=studentName;
}
}
下面是使用PasswdMemeberShipService的例子
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.URI;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import net.jxta.credential.AuthenticationCredential;
import net.jxta.discovery.DiscoveryService;
import net.jxta.document.Advertisement;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.Element;
import net.jxta.document.MimeMediaType;
import net.jxta.document.StructuredDocument;
import net.jxta.document.StructuredDocumentFactory;
import net.jxta.document.StructuredTextDocument;
import net.jxta.document.TextElement;
import net.jxta.exception.PeerGroupException;
import net.jxta.id.ID;
import net.jxta.id.IDFactory;
import net.jxta.impl.membership.PasswdMembershipService;
import net.jxta.membership.Authenticator;
import net.jxta.membership.MembershipService;
import net.jxta.peergroup.PeerGroup;
import net.jxta.peergroup.PeerGroupFactory;
import net.jxta.peergroup.PeerGroupID;
import net.jxta.platform.ModuleSpecID;
import net.jxta.protocol.ModuleImplAdvertisement;
import net.jxta.protocol.PeerGroupAdvertisement;
import net.jxta.impl.peergroup.StdPeerGroupParamAdv; public class PrivatePeerGroup {
private PeerGroup myNetPeerGroup = null, satellaPeerGroup = null,
discoveredSatellaPeerGroup = null;
private final static PeerGroupID satellaPeerGroupID = PeerGroupID
.create(URI.create("jxta:uuid-4d6172676572696e204272756e6f202002")); /** Creates new RootWS */
public PrivatePeerGroup() {
// Starts the JXTA Platform
myNetPeerGroup = this.startJxta();
if (myNetPeerGroup != null) {
System.out.println("JXTA platform Started ...");
} else {
System.err.println("Failed to start JXTA : myNetPeerGroup is null");
System.exit(1);
}
// Generate the parameters:
// login, passwd, peer group name and peer group id
// for creating the Peer Group
String login = "PrivatePeerGroups";
String passwd = "RULE";
String groupName = "SatellaGroup";
// create The Passwd Authenticated Peer Group
satellaPeerGroup = this.createPeerGroup(myNetPeerGroup, groupName,
login, passwd);
// join the satellaPeerGroup
if (satellaPeerGroup != null) {
System.out.println(" Peer Group Created ...");
discoveredSatellaPeerGroup = this.discoverPeerGroup(myNetPeerGroup,
satellaPeerGroupID);
if (discoveredSatellaPeerGroup != null) {
System.out.println(" Peer Group Found ...");
this.joinPeerGroup(discoveredSatellaPeerGroup, login, passwd);
}
}
System.out.println(" Peer Group Joined ...");
// Print the Peer Group Adverstisement on sdt out.
this.printXmlAdvertisement(
"XML Advertisement forPeer Group Advertisement",
satellaPeerGroup.getPeerGroupAdvertisement());
} private PeerGroup createPeerGroup(PeerGroup rootPeerGroup,
String groupName, String login, String passwd) {
// create the Peer Group by doing the following:
// - Create a Peer Group Module Implementation Advertisement and publish
// it
// - Create a Peer Group Adv and publish it
// - Create a Peer Group from the Peer Group Adv and return this object
PeerGroup satellaPeerGroup = null;
PeerGroupAdvertisement satellaPeerGroupAdvertisement;
// Create the PeerGroup Module Implementation Adv
ModuleImplAdvertisement passwdMembershipModuleImplAdv;
passwdMembershipModuleImplAdv = this
.createPasswdMembershipPeerGroupModuleImplAdv(rootPeerGroup);
// Publish it in the parent peer group
DiscoveryService rootPeerGroupDiscoveryService = rootPeerGroup
.getDiscoveryService();
try {
rootPeerGroupDiscoveryService.publish(
passwdMembershipModuleImplAdv, PeerGroup.DEFAULT_LIFETIME,
PeerGroup.DEFAULT_EXPIRATION);
rootPeerGroupDiscoveryService
.remotePublish(passwdMembershipModuleImplAdv,
PeerGroup.DEFAULT_EXPIRATION);
} catch (java.io.IOException e) {
System.err.println("Can't Publish passwdMembershipModuleImplAdv");
System.exit(1);
}
// Now, Create the Peer Group Advertisement
satellaPeerGroupAdvertisement = this.createPeerGroupAdvertisement(
passwdMembershipModuleImplAdv, groupName, login, passwd);
// Publish it in the parent peer group
try {
rootPeerGroupDiscoveryService.publish(
satellaPeerGroupAdvertisement, PeerGroup.DEFAULT_LIFETIME,
PeerGroup.DEFAULT_EXPIRATION);
rootPeerGroupDiscoveryService
.remotePublish(satellaPeerGroupAdvertisement,
PeerGroup.DEFAULT_EXPIRATION);
} catch (java.io.IOException e) {
System.err.println("Can't Publish satellaPeerGroupAdvertisement");
System.exit(1);
}
// Finally Create the Peer Group
if (satellaPeerGroupAdvertisement == null) {
System.err.println("satellaPeerGroupAdvertisement is null");
}
try {
satellaPeerGroup = rootPeerGroup
.newGroup(satellaPeerGroupAdvertisement);
} catch (net.jxta.exception.PeerGroupException e) {
System.err
.println("Can't create Satella Peer Group from Advertisement");
e.printStackTrace();
return null;
}
return satellaPeerGroup;
} private PeerGroupAdvertisement createPeerGroupAdvertisement(
ModuleImplAdvertisement passwdMembershipModuleImplAdv,
String groupName, String login, String passwd) {
// Create a PeerGroupAdvertisement for the peer group
PeerGroupAdvertisement satellaPeerGroupAdvertisement = (PeerGroupAdvertisement) AdvertisementFactory
.newAdvertisement(PeerGroupAdvertisement.getAdvertisementType());
// Instead of creating a new group ID each time, by using the
// line below
// satellaPeerGroupAdvertisement.setPeerGroupID
// (IDFactory.newPeerGroupID());
// I use a fixed ID so that each time I start PrivatePeerGroup,
// it creates the same Group
satellaPeerGroupAdvertisement.setPeerGroupID(satellaPeerGroupID);
satellaPeerGroupAdvertisement
.setModuleSpecID(passwdMembershipModuleImplAdv
.getModuleSpecID());
satellaPeerGroupAdvertisement.setName(groupName);
satellaPeerGroupAdvertisement
.setDescription("Peer Group using Password Authentication");
// Now create the Structured Document Containing the login and
// passwd informations. Login and passwd are put into the Param
// section of the peer Group
if (login != null) {
StructuredTextDocument loginAndPasswd = (StructuredTextDocument) StructuredDocumentFactory
.newStructuredDocument(new MimeMediaType("text/xml"),
"Parm");
String loginAndPasswdString = login + ":"
+ PasswdMembershipService.makePsswd(passwd) + ":";
TextElement loginElement = loginAndPasswd.createElement("login",
loginAndPasswdString);
loginAndPasswd.appendChild(loginElement);
// All Right, now that loginAndPasswdElement
// (The strucuted document
// that is the Param Element for The PeerGroup Adv
// is done, include it in the Peer Group Advertisement
satellaPeerGroupAdvertisement.putServiceParam(
PeerGroup.membershipClassID, loginAndPasswd);
}
return satellaPeerGroupAdvertisement;
} private ModuleImplAdvertisement createPasswdMembershipPeerGroupModuleImplAdv(
PeerGroup rootPeerGroup) {
// Create a ModuleImpl Advertisement for the Passwd
// Membership Service Take a allPurposePeerGroupImplAdv
// ModuleImplAdvertisement parameter to
// Clone some of its fields. It is easier than to recreate
// everything from scratch
// Try to locate where the PasswdMembership is within this
// ModuleImplAdvertisement.
// For a PeerGroup Module Impl, the list of the services
// (including Membership) are located in the Param section
ModuleImplAdvertisement allPurposePeerGroupImplAdv = null;
try {
allPurposePeerGroupImplAdv = rootPeerGroup
.getAllPurposePeerGroupImplAdvertisement();
} catch (java.lang.Exception e) {
System.err
.println("Can't Execute: getAllPurposePeerGroupImplAdvertisement();");
System.exit(1);
}
ModuleImplAdvertisement passwdMembershipPeerGroupModuleImplAdv = allPurposePeerGroupImplAdv;
ModuleImplAdvertisement passwdMembershipServiceModuleImplAdv = null;
StdPeerGroupParamAdv passwdMembershipPeerGroupParamAdv = null;
passwdMembershipPeerGroupParamAdv = new StdPeerGroupParamAdv(
allPurposePeerGroupImplAdv.getParam());
Hashtable allPurposePeerGroupServicesHashtable = (Hashtable) passwdMembershipPeerGroupParamAdv
.getServices();
Enumeration allPurposePeerGroupServicesEnumeration = allPurposePeerGroupServicesHashtable
.keys();
boolean membershipServiceFound = false;
while ((!membershipServiceFound)
&& (allPurposePeerGroupServicesEnumeration.hasMoreElements())) {
Object allPurposePeerGroupServiceID = allPurposePeerGroupServicesEnumeration
.nextElement();
if (allPurposePeerGroupServiceID
.equals(PeerGroup.membershipClassID)) {
// allPurposePeerGroupMemershipServiceModuleImplAdv is
// the all Purpose Mermbership Service for the all
// purpose Peer Group Module Impl adv
ModuleImplAdvertisement allPurposePeerGroupMemershipServiceModuleImplAdv = (ModuleImplAdvertisement) allPurposePeerGroupServicesHashtable
.get(allPurposePeerGroupServiceID);
// Create the passwdMembershipServiceModuleImplAdv
passwdMembershipServiceModuleImplAdv = this
.createPasswdMembershipServiceModuleImplAdv(allPurposePeerGroupMemershipServiceModuleImplAdv);
// Remove the All purpose Membership Service implementation
allPurposePeerGroupServicesHashtable
.remove(allPurposePeerGroupServiceID);
// And Replace it by the Passwd Membership Service
// Implementation
allPurposePeerGroupServicesHashtable.put(
PeerGroup.membershipClassID,
passwdMembershipServiceModuleImplAdv);
membershipServiceFound = true;
// Now the Service Advertisements are complete. Let's
// update the passwdMembershipPeerGroupModuleImplAdv by
// Updating its param
passwdMembershipPeerGroupModuleImplAdv
.setParam((Element) passwdMembershipPeerGroupParamAdv
.getDocument(MimeMediaType.XMLUTF8));
// Update its Spec ID This comes from the
// Instant P2P PeerGroupManager Code (Thanks !!!!)
if (!passwdMembershipPeerGroupModuleImplAdv.getModuleSpecID()
.equals(PeerGroup.allPurposePeerGroupSpecID)) {
passwdMembershipPeerGroupModuleImplAdv
.setModuleSpecID(IDFactory
.newModuleSpecID(passwdMembershipPeerGroupModuleImplAdv
.getModuleSpecID().getBaseClass()));
} else {
ID passwdGrpModSpecID = ID.create(URI.create("urn"
+ "jxta:uuid-" + "DeadBeefDeafBabaFeedBabe00000001"
+ "04" + "06"));
passwdMembershipPeerGroupModuleImplAdv
.setModuleSpecID((ModuleSpecID) passwdGrpModSpecID);
} // End Else
membershipServiceFound = true;
} // end if (allPurposePeerGroupServiceID.
// equals(PeerGroup.membershipClassID))
}// end While
return passwdMembershipPeerGroupModuleImplAdv;
} private ModuleImplAdvertisement createPasswdMembershipServiceModuleImplAdv(
ModuleImplAdvertisement allPurposePeerGroupMemershipServiceModuleImplAdv) {
// Create a new ModuleImplAdvertisement for the
// Membership Service
ModuleImplAdvertisement passwdMembershipServiceModuleImplAdv = (ModuleImplAdvertisement) AdvertisementFactory
.newAdvertisement(ModuleImplAdvertisement
.getAdvertisementType());
passwdMembershipServiceModuleImplAdv
.setModuleSpecID(PasswdMembershipService.passwordMembershipSpecID);
passwdMembershipServiceModuleImplAdv
.setCode(PasswdMembershipService.class.getName());
passwdMembershipServiceModuleImplAdv
.setDescription(" Module Impl Advertisement for the PasswdMembership Service");
passwdMembershipServiceModuleImplAdv
.setCompat(allPurposePeerGroupMemershipServiceModuleImplAdv
.getCompat());
passwdMembershipServiceModuleImplAdv
.setUri(allPurposePeerGroupMemershipServiceModuleImplAdv
.getUri());
passwdMembershipServiceModuleImplAdv
.setProvider(allPurposePeerGroupMemershipServiceModuleImplAdv
.getProvider());
return passwdMembershipServiceModuleImplAdv;
} private PeerGroup discoverPeerGroup(PeerGroup myNetPeerGroup,
PeerGroupID satellaPeerGroupID) {
// First discover the peer group
// In most cases we should use discovery listeners so that
// we can do the discovery asynchroneously.
// Here I won't, for increased simplicity and because
// The Peer Group Advertisement is in the local cache for
// sure
PeerGroup satellaPeerGroup;
DiscoveryService myNetPeerGroupDiscoveryService = null;
if (myNetPeerGroup != null) {
myNetPeerGroupDiscoveryService = myNetPeerGroup
.getDiscoveryService();
} else {
System.err
.println("Can't join Peer Group since it's parent is null");
System.exit(1);
}
boolean isGroupFound = false;
Enumeration localPeerGroupAdvertisementEnumeration = null;
PeerGroupAdvertisement satellaPeerGroupAdvertisement = null;
while (!isGroupFound) {
try {
localPeerGroupAdvertisementEnumeration = myNetPeerGroupDiscoveryService
.getLocalAdvertisements(DiscoveryService.GROUP, "GID",
satellaPeerGroupID.toString());
} catch (java.io.IOException e) {
System.out.println("Can't Discover Local Adv");
}
if (localPeerGroupAdvertisementEnumeration != null) {
while (localPeerGroupAdvertisementEnumeration.hasMoreElements()) {
PeerGroupAdvertisement pgAdv = null;
pgAdv = (PeerGroupAdvertisement) localPeerGroupAdvertisementEnumeration
.nextElement();
if (pgAdv.getPeerGroupID().equals(satellaPeerGroupID)) {
satellaPeerGroupAdvertisement = pgAdv;
isGroupFound = true;
break;
}
}
}
try {
Thread.sleep(5 * 1000);
} catch (Exception e) {
}
}
try {
satellaPeerGroup = myNetPeerGroup
.newGroup(satellaPeerGroupAdvertisement);
} catch (net.jxta.exception.PeerGroupException e) {
System.err.println("Can't create Peer Group from Advertisement");
e.printStackTrace();
return null;
}
return satellaPeerGroup;
} private void joinPeerGroup(PeerGroup satellaPeerGroup, String login,
String passwd) {
// Get the Heavy Weight Paper for the resume
// Alias define the type of credential to be provided
StructuredDocument creds = null;
try {
// Create the resume to apply for the Job
// Alias generate the credentials for the Peer Group
AuthenticationCredential authCred = new AuthenticationCredential(
satellaPeerGroup, null, creds);
// Create the resume to apply for the Job
// Alias generate the credentials for the Peer Group
MembershipService membershipService = satellaPeerGroup
.getMembershipService();
// Send the resume and get the Job application form
// Alias get the Authenticator from the Authentication creds
Authenticator auth = membershipService.apply(authCred);
// Fill in the Job Application Form
// Alias complete the authentication
completeAuth(auth, login, passwd);
// Check if I got the Job
// Alias Check if the authentication that was submitted was
// accepted.
if (!auth.isReadyForJoin()) {
System.out.println("Failure in authentication.");
System.out
.println("Group was not joined. Does not know how to complete authenticator");
}
// I got the Job, Join the company
// Alias I the authentication I completed was accepted,
// therefore join the Peer Group accepted.
membershipService.join(auth);
} catch (Exception e) {
System.out.println("Failure in authentication.");
System.out.println("Group was not joined. Login was incorrect.");
e.printStackTrace();
}
} private void completeAuth(Authenticator auth, String login, String passwd)
throws Exception {
Method[] methods = auth.getClass().getMethods();
Vector authMethods = new Vector();
// Find out with fields of the application needs to be
// filled
// Alias Go through the methods of the Authenticator
// class and
// copy them sorted by name into a vector.
for (int eachMethod = 0; eachMethod < methods.length; eachMethod++) {
if (methods[eachMethod].getName().startsWith("setAuth")) {
if (Modifier.isPublic(methods[eachMethod].getModifiers())) {
// sorted insertion.
for (int doInsert = 0; doInsert <= authMethods.size(); doInsert++) {
int insertHere = -1;
if (doInsert == authMethods.size())
insertHere = doInsert;
else {
if (methods[eachMethod].getName().compareTo(
((Method) authMethods.elementAt(doInsert))
.getName()) <= 0)
insertHere = doInsert;
} // end else
if (-1 != insertHere) {
authMethods.insertElementAt(methods[eachMethod],
insertHere);
break;
} // end if ( -1 != insertHere)
} // end for (int doInsert=0
} // end if (modifier.isPublic
} // end if (methods[eachMethod]
} // end for (int eachMethod)
Object[] AuthId = { login };
Object[] AuthPasswd = { passwd };
for (int eachAuthMethod = 0; eachAuthMethod < authMethods.size(); eachAuthMethod++) {
Method doingMethod = (Method) authMethods.elementAt(eachAuthMethod);
String authStepName = doingMethod.getName().substring(7);
if (doingMethod.getName().equals("setAuth1Identity")) {
// Found identity Method, providing identity
doingMethod.invoke(auth, AuthId);
} else if (doingMethod.getName().equals("setAuth2_Password")) {
// Found Passwd Method, providing passwd
doingMethod.invoke(auth, AuthPasswd);
}
}
} private void printXmlAdvertisement(String title, Advertisement adv) {
// First, Let's print a "nice" Title
String separator = "";
for (int i = 0; i < title.length() + 4; i++) {
separator = separator + "-";
}
System.out.println(separator);
System.out.println("| " + title + " |");
System.out.println(separator);
// Now let's print the Advertisement
System.out.println(adv.toString());
// Let's end up with a line
System.out.println(separator);
} /** Starts the jxta platform */
private PeerGroup startJxta() {
PeerGroup myNetPeerGroup = null;
try {
myNetPeerGroup = PeerGroupFactory.newNetPeerGroup();
} catch (PeerGroupException e) {
// could not instantiate the group, print the stack
// and exit
System.out.println("fatal error : group creation failure");
e.printStackTrace();
System.exit(1);
}
return myNetPeerGroup;
} public static void main(String args[]) {
PrivatePeerGroup satellaRoot = new PrivatePeerGroup();
System.exit(0);
}
}
这段代码是基于旧版本的jxta实现，所以运行起来需要旧版本的jxta支持，下载地址：www.samspublishing.com中，搜索jxta并且点击download
我还没有弄出新版本的实现，总是出现兼容问题，让我很郁闷，希望得到帮组啊
CSDN 下载地址：http://download.csdn.net/source/1442761
JXTA中定义自己的成员服务的更多相关文章
- PHP中如何定义类及其成员属性与操作
1.类的定义: i. 类的关键字定义使用class 1.定义一个空类 Class Person{}; 2.定义一个有成员属性和操作的类 Class Person{ 成员属性........ 操 ...
- 继承的基本概念： （1）Java不支持多继承，也就是说子类至多只能有一个父类。 （2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法。 （3）子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量不能被继承。 （4）子类中定义的成员方法，并且这个方法的名字返回类型，以及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法不能被继承。 分析以上程
继承的基本概念: (1)Java不支持多继承,也就是说子类至多只能有一个父类. (2)子类继承了其父类中不是私有的成员变量和成员方法,作为自己的成员变量和方法.(3)子类中定义的成员变量和父类中定义的 ...
- c++中类模版中的static数据成员的定义
这个有点绕. 如下: template <typename T> class A{ ......... static std::allocate<T> alloc_; }; t ...
- 定义一个共享数据块DB1 在DB1中定义一个数组 用程序 访问数据里面的某一个成员或者地址连续的成员
提纲 : 定义一个共享数据块 DB1 在DB1 中定义数组 用SFC21 实现 实现全部数组元素的赋一样的值 实现 给数组中的某一个元素赋值 实现 对数组中的全部元素赋值 实现将数组中的某个 或者 某 ...
- 项目实践之工作流引擎基本文档！Activiti工作流框架中流程引擎API和服务详解
流程引擎的API和服务 流程引擎API(ProcessEngine API)是与Activiti打交道的最常用方式 Activiti从ProcessEngine开始.在ProcessEngine中,可 ...
- 在php中定义常量时,const与define的区别?
问]在php中定义常量时,const与define的区别? [答]使用const使得代码简单易读,const本身就是一个语言结构,而define是一个函数.另外const在编译时要比define快很 ...
- 如何使用其他文件中定义的类Python
我在文件a.py中定义了一个类class A(object),现在想在b.py中的类B中某个函数中创建一个A的对象,需要如何操作呢? 我在b的头加了import a.py然后使用语句 obj = A( ...
- Java反射机制可以动态修改实例中final修饰的成员变量吗？
问题:Java反射机制可以动态修改实例中final修饰的成员变量吗? 回答是分两种情况的. 1. 当final修饰的成员变量在定义的时候就初始化了值,那么java反射机制就已经不能动态修改它的值了. ...
- C++中的static数据成员与static成员函数
本文要点: 1.static成员它不像普通的数据成员,static数据成员独立于该类的任意对象而存在,每个static数据成员是与类关联的对象,并不与该类的对象相关联! aka:每个static数据成 ...
随机推荐
- HeadFirst Jsp 06 (会话管理)
现在我们希望能够跨多个请求保留客户特定的状态. 现在, 模型中的业务只是检查请求中的参数, 并返回一个响应(建议), 应用中没有谁记得在当前请求之前与这个客户之间发生过什么. 与一个客户的整个会话期间 ...
- String.indexOf()
int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引. int indexOf(int ch, int fromIndex) 从指定的索引开始搜索,返回在此字符串中第一次 ...
- git deployment strategy
http://nicolasgallagher.com/simple-git-deployment-strategy-for-static-sites/ You can still ignore a ...
- CSS之弧形阴影
简述 网页上经常会出现一些弧形的阴影效果,看起来很漂亮,下面我们来讲述下如何用CSS来实现一个弧形阴影. 简述 阴影 效果 注释 标题 效果 源码 合并 效果 源码 阴影 效果 首先实现一个简单的阴影 ...
- HDU 2176 (Nim博弈 先手取胜方案) 取(m堆)石子游戏
切切水题,放松心情:-D #include <cstdio> + ; int a[maxn]; int main() { //freopen("in.txt", &qu ...
- mysql大数据导出导入
1)导出 select * from users into outfile '/tmp/users.txt';或 select * from users where sex=1 into outfil ...
- PHP学习笔记01——基础语法
<!DOCTYPE html> <html> <?php // 1.使用$加变量名来表示变量,php是弱类型语言,不要求在使用变量前声明,第一次赋值时变量才被创建 $a ...
- activiti 引擎 数据库设计说明书
1.结构设计 1.1. 逻辑结构设计 Activiti使用到的表都是ACT_开头的. ACT_RE_*: ’RE’表示repository(存储),RepositoryService接口所操作的 ...
- 【英语】Bingo口语笔记(75) - 元音辅音的辨读
- android学习视频（实战项目演练）
1.基于Android平台实战无线点餐系统(客户端(Client)和服务端(Server))①http://kuai.xunlei.com/d/xmBrDwI8CAAyXVFRa3d②http://k ...