guanxf -凯发k8网页登录

createtree(1, orgnodetree, sameorgnodes, 0);


@noargsconstructor
@allargsconstructor
@getter
@setter
public class nodetree {
    private  string pname;
    private  string name;
    private  int level;
    private list children;
}

private void createtree(int leave, int ind, map pindexnodenamemap, list childnodes) {
     map cindexnodenamemap = new hashmap();
     //构建树
     int treeno = pindexnodenamemap.size();
     if (treeno == 0) {
         return;
     }
     int group = 0;
     for (int i = ind; i < childnodes.size(); i  ) {
         nodevo node = childnodes.get(i);
         long index = node.getid() % treeno;
         nodetree pnode = pindexnodenamemap.get(index   "");
         list children = pnode.getchildren();
         if (collectionutils.isempty(children)) {
             children = new arraylist();
         }
         if (children.size() > 2) {
             leave  ;
             createtree(leave, i, cindexnodenamemap, childnodes);
             break;
         } else {
             nodetree child = new nodetree();
             child.setlevel(leave);
             child.setpname(pnode.getname());
             child.setname(node.getnodename());
             children.add(child);
             pnode.setchildren(children);
             cindexnodenamemap.put(group   "", child);
             group  ;
         }
     }
 }


private boolean createtree(int level, list parentnodes, list childnodes, int beginindex) {
    //构建树
list nextlevelnodes = new arraylist<>();
    for (int i = beginindex; i < childnodes.size(); i  ) {
        int parentcount = 1;
        for (nodetree pnode : parentnodes) {
            list children = pnode.getchildren();
            if (collectionutils.isempty(children)) {
                children = new arraylist();
pnode.setchildren(children);
}
            if (children.size() >= 3) {
                if(parentcount >= parentnodes.size()){
                    return createtree(  level, nextlevelnodes, childnodes, beginindex);
}
            } else {
                if (beginindex >= childnodes.size()) {
                    return true;
}
                nodetree child = new nodetree();
child.setlevel(level);
child.setpname(pnode.getname());
nodevo node = childnodes.get(beginindex);
child.setname(node.getnodename());
pnode.getchildren().add(child);
nextlevelnodes.add(child);
beginindex  ;
}
            parentcount  ;
}
    }
    return true;
}

进入“控制面板”——“用户账户”-凭据管理器——windows凭据

找到了git的用户名密码。修改正确后ok

元注解：

　　元注解的作用就是负责注解其他注解。java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。java5.0定义的元注解：
　　　　1.@target,
　　　　2.@retention,
　　　　3.@documented,
　　　　4.@inherited

@target(type)
@retention(runtime)
public @interface table {
    /**
     * (optional) the name of the table.
     * 

 * defaults to the entity name.
     */
 string name() default "";
}

@target({method, field})
@retention(runtime)
public @interface column {

    /**
     * (optional) the name of the column. defaults to
     * the property or field name.
     */
 string name() default "";
}

@table(name = "t_s_user")
public class user {
    @column(name="name")
    private string name;

 @column(name="pwd")
    private string pwd;

    public string getname() {
        return name;
 }

    public void setname(string name) {
        this.name = name;
 }

    public string getpwd() {
        return pwd;
 }

    public void setpwd(string pwd) {
        this.pwd = pwd;
 }
}

public static void print() {
  system.out.println("table's name："   user.class.getannotation(table.class).name());
 field[] fields = user.class.getdeclaredfields();
    for (int i = 0; i < fields.length; i  ) {
        field field = fields[i];
 system.out.println("field's type:"   field.gettype().getname());
 system.out.println("field's columnname:"   field.getannotation(column.class).name());
 }
}

@springbootapplication
@componentscan
@import({dbconfiguration.class, resourceconfiguration.class,appconfiguration.class})
public class application extends springbootservletinitializer {
    @override
 protected springapplicationbuilder configure(springapplicationbuilder application) {
        return application.sources(application.class);
 }

           org.springframework.boot
           spring-boot-starter-tomcat
           provided
       

   org.springframework.boot
   spring-boot-legacy
   1.0.2.release



   javax.servlet
   javax.servlet-api
   3.0.1


   javax.servlet
   javax.servlet-api
   3.0.1



   commons-fileupload
   commons-fileupload
   1.3.1

the purpose of this project is to provide generic, lightweight and easy to use dao implementation for relational databases based on from , compatible with spring data umbrella of projects.

design objectives

• lightweight, fast and low-overhead. only a handful of classes, no xml, annotations, reflection
• this is not full-blown orm. no relationship handling, lazy loading, dirty checking, caching
• crud implemented in seconds
• for small applications where jpa is an overkill
• use when simplicity is needed or when future migration e.g. to jpa is considered
• minimalistic support for database dialect differences (e.g. transparent paging of results)

features

each dao provides built-in support for:

• mapping to/from domain objects through abstraction
• generated and user-defined primary keys
• extracting generated key
• compound (multi-column) primary keys
• immutable domain objects
• paging (requesting subset of results)
• sorting over several columns (database agnostic)
• optional support for many-to-one relationships
• supported databases (continuously tested):
  • mysql
  • postgresql
  • h2
  • hsqldb
  • derby
  • ms sql server (2008, 2012)
  • oracle 10g / 11g (9i should work too)
  • ...and most likely many others
• easily extendable to other database dialects via class.
• easy retrieval of records by id

api

compatible with spring data abstraction, all these methods are implemented for you:

public interface pagingandsortingrepository extends crudrepository {
 t  save(t entity);
iterable save(iterable entities);
 t  findone(id id);
boolean exists(id id);
iterable findall();
   long count();
   void delete(id id);
   void delete(t entity);
   void delete(iterable entities);
   void deleteall();
iterable findall(sort sort);
page findall(pageable pageable);
iterable findall(iterable ids);
}

pageable and sort parameters are also fully supported, which means you get paging and sorting by arbitrary properties for free. for example say you have userrepository extending pagingandsortingrepository interface (implemented for you by the library) and you request 5th page of users table, 10 per page, after applying some sorting:

page page = userrepository.findall(
new pagerequest(
5, 10, 
new sort(
new order(desc, "reputation"), 
new order(asc, "user_name")
)
)
);

spring data jdbc repository library will translate this call into (postgresql syntax):

select *
from users
order by reputation desc, user_name asc
limit 50 offset 10

...or even (derby syntax):

select * from (
select row_number() over () as row_num, t.*
from (
select * 
from users 
order by reputation desc, user_name asc
) as t
) as a 
where row_num between 51 and 60

no matter which database you use, you'll get page object in return (you still have to provide rowmapper yourself to translate from to domain object). if you don't know spring data project yet, is a wonderful abstraction, not only encapsulating list, but also providing metadata such as total number of records, on which page we currently are, etc.

reasons to use

• you consider migration to jpa or even some nosql database in the future.

  since your code will rely only on methods defined in and from umbrella project you are free to switch from implementation (from this project) to: , , or . they all implement the same common api. of course don't expect that switching from jdbc to jpa or mongodb will be as simple as switching imported jar dependencies - but at least you minimize the impact by using same dao api.

• you need a fast, simple jdbc wrapper library. jpa or even is an overkill

• you want to have full control over generated sql if needed

• you want to work with objects, but don't need lazy loading, relationship handling, multi-level caching, dirty checking... you need and not much more

• you want to by

• you are already using spring or maybe even , but still feel like there is too much manual work

• you have very few database tables

getting started

for more examples and working code don't forget to examine .

prerequisites

maven coordinates:

com.nurkiewicz.jdbcrepository
jdbcrepository
0.4

this project is available under maven central repository.

alternatively you can .

in order to start your project must have datasource bean present and transaction management enabled. here is a minimal mysql configuration:

@enabletransactionmanagement
@configuration
public class minimalconfig {
@bean
public platformtransactionmanager transactionmanager() {
return new datasourcetransactionmanager(datasource());
}
@bean
public datasource datasource() {
mysqlconnectionpooldatasource ds = new mysqlconnectionpooldatasource();
ds.setuser("user");
ds.setpassword("secret");
ds.setdatabasename("db_name");
return ds;
}
}

entity with auto-generated key

say you have a following database table with auto-generated key (mysql syntax):

create table comments (
id int auto_increment,
user_name varchar(256),
contents varchar(1000),
created_time timestamp not null,
primary key (id)
);

first you need to create domain object mapping to that table (just like in any other orm):

public class comment implements persistable {
private integer id;
private string username;
private string contents;
private date createdtime;
@override
public integer getid() {
return id;
}
@override
public boolean isnew() {
return id == null;
}
//getters/setters/constructors/...
}

apart from standard java boilerplate you should notice implementing where integer is the type of primary key. persistable is an interface coming from spring data project and it's the only requirement we place on your domain object.

finally we are ready to create our dao:

@repository
public class commentrepository extends jdbcrepository {
public commentrepository() {
super(row_mapper, row_unmapper, "comments");
}
public static final rowmapper row_mapper = //see below
private static final rowunmapper row_unmapper = //see below
@override
protected  s postcreate(s entity, number generatedid) {
entity.setid(generatedid.intvalue());
return entity;
}
}

public static final rowmapper row_mapper = new rowmapper() {
@override
public comment maprow(resultset rs, int rownum) throws sqlexception {
return new comment(
rs.getint("id"),
rs.getstring("user_name"),
rs.getstring("contents"),
rs.gettimestamp("created_time")
);
}
};

private static final rowunmapper row_unmapper = new rowunmapper() {
@override
public map mapcolumns(comment comment) {
map mapping = new linkedhashmap();
mapping.put("id", comment.getid());
mapping.put("user_name", comment.getusername());
mapping.put("contents", comment.getcontents());
mapping.put("created_time", new java.sql.timestamp(comment.getcreatedtime().gettime()));
return mapping;
}
};

create table users (
user_name varchar(255),
date_of_birth timestamp not null,
enabled bit(1) not null,
primary key (user_name)
);

public class user implements persistable {
private transient boolean persisted;
private string username;
private date dateofbirth;
private boolean enabled;
@override
public string getid() {
return username;
}
@override
public boolean isnew() {
return !persisted;
}
public void setpersisted(boolean persisted) {
this.persisted = persisted;
}
//getters/setters/constructors/...
}

@repository
public class userrepository extends jdbcrepository {
public userrepository() {
super(row_mapper, row_unmapper, "users", "user_name");
}
public static final rowmapper row_mapper = //...
public static final rowunmapper row_unmapper = //...
@override
protected  s postupdate(s entity) {
entity.setpersisted(true);
return entity;
}
@override
protected  s postcreate(s entity, number generatedid) {
entity.setpersisted(true);
return entity;
}
}

create table boarding_pass (
flight_no varchar(8) not null,
seq_no int not null,
passenger varchar(1000),
seat char(3),
primary key (flight_no, seq_no)
);

public class boardingpass implements persistable {
private transient boolean persisted;
private string flightno;
private int seqno;
private string passenger;
private string seat;
@override
public object[] getid() {
return pk(flightno, seqno);
}
@override
public boolean isnew() {
return !persisted;
}
//getters/setters/constructors/...
}

public class boardingpassrepository extends jdbcrepository {
public boardingpassrepository() {
this("boarding_pass");
}
public boardingpassrepository(string tablename) {
super(mapper, unmapper, new tabledescription(tablename, null, "flight_no", "seq_no")
);
}
public static final rowmapper row_mapper = //...
public static final rowunmapper unmapper = //...
}

boardingpass pass = boardingpassrepository.findone(new object[] {"foo-1022", 42});

import static com.nurkiewicz.jdbcrepository.jdbcrepository.pk;
//...
boardingpass foundflight = boardingpassrepository.findone(pk("foo-1022", 42));

$ mvn install

results :
tests run: 484, failures: 0, errors: 0, skipped: 295